Como criar aplicativos na era da IA

1. Visão geral

Neste laboratório, você vai usar os produtos de IA generativa do Google para criar infraestrutura no Google Cloud com a ajuda do Gemini Cloud Assist, consultar dados do BigQuery usando recursos de linguagem natural para SQL do Data Canvas, escrever código em notebooks do Colab Enterprise Jupyter e no Eclipse Theia (Visual Studio Code) com a ajuda do Gemini Code Assist e integrar recursos de pesquisa e chat de IA criados com base em fontes de embasamento do Cloud Storage e do BigQuery no Vertex AI Agent Builder.

Nosso objetivo é criar um site de receitas e culinária chamado AI Recipe Haven. O site será criado em Python e Streamlit e terá duas páginas principais. O Cooking Advice vai hospedar um chatbot que vamos criar usando o Gemini e uma fonte fundamentada do Vertex AI Agent Builder vinculada a um grupo de livros de receitas. Ele vai oferecer dicas de culinária e responder a perguntas relacionadas a esse tema. A Pesquisa de receitas será um mecanismo de pesquisa alimentado pelo Gemini, desta vez com base em um banco de dados de receitas do BigQuery.

Se você tiver dificuldades com algum código neste exercício, as soluções para todos os arquivos de código estarão no repositório do GitHub do exercício, na ramificação solution.

Objetivos

Neste laboratório, você aprenderá a fazer o seguinte:

Ativar e usar o Gemini Cloud Assist
Criar um app de pesquisa na Vertex AI Agent Builder para o chatbot de dicas de culinária
Carregar e limpar dados em um notebook do Colab Enterprise com a ajuda do Gemini Code Assist
Criar um app de pesquisa no Vertex AI Agent Builder para o gerador de receitas
Estruturar o aplicativo da Web principal em Python e Streamlit com a ajuda do Gemini
Implantar o aplicativo da Web no Cloud Run
Conectar a página "Cooking Advice" ao app do Agent Builder "cookbook-search"
(Opcional) Conecte a página de pesquisa de receitas ao app do Agent Builder de pesquisa de receitas
(Opcional) Conheça o aplicativo final

2. Pré-requisitos

Se você ainda não tiver uma Conta do Google, crie uma.
- Use uma conta pessoal em vez de uma conta escolar ou de trabalho. As contas escolares e de trabalho podem ter restrições que impedem a ativação das APIs necessárias para este laboratório.

3. Configurar o projeto

Faça login no Console do Google Cloud.
Ative o faturamento no console do Cloud.
- A conclusão deste laboratório custa menos de US $1 em recursos do Cloud.
- Siga as etapas no final deste laboratório para excluir recursos e evitar mais cobranças.
- Novos usuários podem aproveitar o teste sem custos financeiros de US$300.
- Vai participar de um laboratório prático virtual? Um crédito de US$5 pode estar disponível.
Crie um projeto ou reutilize um projeto existente.
Confirme se o faturamento está ativado em Meus projetos no Cloud Billing
- Se o novo projeto mostrar Billing is disabled na coluna Billing account:
  1. Clique nos três pontos na coluna Actions.
  2. Clique em Mudar faturamento.
  3. Selecione a conta de faturamento que você quer usar.
- Se você estiver participando de um evento ao vivo, a conta provavelmente será chamada de Conta de faturamento de avaliação do Google Cloud Platform.

4. Ativar e usar o Gemini Cloud Assist

Nesta tarefa, vamos ativar e usar o Gemini Cloud Assist. Ao trabalhar no console do Google Cloud, o Gemini Cloud Assist pode oferecer conselhos, ajudar você a criar, configurar e monitorar sua infraestrutura em nuvem do Google Cloud e até sugerir comandos gcloud e escrever scripts do Terraform.

Para ativar o Cloud Assist, clique na caixa de pesquisa na parte de cima da interface do console do Cloud e selecione Perguntar ao Gemini ou Perguntar ao Gemini no console do Cloud.
Role até a seção "API obrigatória" da página e clique em Ativar na API Gemini para Google Cloud.
Se uma interface de chat não aparecer imediatamente, clique em Iniciar conversa. Comece pedindo ao Gemini para explicar alguns dos benefícios de usar o editor do Cloud Shell. Reserve alguns minutos para analisar a resposta gerada.
Em seguida, pergunte sobre os benefícios do Agent Builder e como ele pode ajudar a fundamentar as respostas generativas.
Por fim, vamos fazer uma comparação. Na conversa no Gemini do console do Google Cloud, faça a seguinte pergunta:
```
What are the major steps to creating a search app grounded in a GCS data source using Vertex AI Agent builder?
```

5. Criar um app de pesquisa na Vertex AI Agent Builder para o chatbot de dicas de culinária

O site que estamos criando terá uma página com dicas de culinária e um chatbot projetado para ajudar os usuários a encontrar respostas para perguntas relacionadas a culinária. Ele vai usar o Gemini com base em uma fonte que contém 70 livros de receitas de domínio público. Os livros de receitas vão atuar como a fonte de informações que o Gemini usa ao responder a perguntas.

Use a caixa de pesquisa do console do Cloud para navegar até a Vertex AI. No painel, clique em Ativar todas as APIs recomendadas. Isso pode levar alguns minutos. Se aparecer uma caixa pop-up informando que a API Vertex AI precisa ser ativada, clique em Ativar. Quando as APIs estiverem ativadas, siga para a próxima etapa.
Use a pesquisa para acessar o Agent Builder e clique em Continuar e ativar a API.
Como o Gemini sugeriu em nossa busca por conselhos anterior, criar um app de pesquisa no Agent Builder começa com a criação de uma fonte de dados confiável. Quando o usuário pesquisa, o Gemini entende a pergunta e como criar respostas inteligentes, mas busca na fonte embasada as informações usadas nessa resposta, em vez de usar o conhecimento próprio.No menu à esquerda, navegue até Repositórios de dados e Criar repositório de dados.
Os livros de receitas de domínio público que estamos usando para fundamentar nossa página de dicas de culinária estão em um bucket do Cloud Storage em um projeto externo. Selecione o tipo de origem do Cloud Storage.
Examine, mas não mude as opções padrão relacionadas ao tipo de informação que estamos importando. Deixe o tipo de importação definido como Pasta e, para o caminho do bucket, use: labs.roitraining.com/labs/old-cookbooks e clique em Continuar.
Nomeie o repositório de dados: old-cookbooks. Clique em EDITAR e mude o ID para old-cookbooks-id. Depois, Crie o repositório de dados.

O Vertex AI Agent Builder é compatível com vários tipos de apps, e o repositório de dados atua como a fonte de verdade para cada um deles. Os apps de pesquisa são bons para uso geral e pesquisa. Os apps de chat são para fluxos generativos em aplicativos de chatbot/voicebot baseados no Dataflow. Os apps de recomendações ajudam a criar mecanismos de recomendação melhores. Os apps de agente são para criar agentes com tecnologia de IA generativa. No fim das contas, o agente provavelmente seria a melhor opção para o que queremos fazer, mas como o produto está em prévia, vamos continuar com o tipo de app de pesquisa.

Use o menu à esquerda para navegar até Apps e clique em Criar um novo app.
Clique em Criar no card Pesquisar no site. Nomeie o app como cookbook-search. Clique em Editar e defina o ID do app como cookbook-search-id. Defina a empresa como Google e clique em Continuar.
Verifique o repositório de dados old-cookbooks que você criou há algumas etapas e Crie o app de pesquisa.

Se você examinar a guia Atividade, provavelmente vai notar que os livros de receitas ainda estão sendo importados e indexados. O Agent Builder vai levar mais de cinco minutos para indexar as milhares de páginas contidas nos 70 livros de receitas que fornecemos. Enquanto ele funciona, vamos carregar e limpar alguns dados do banco de dados de receitas para nosso gerador.

6. Carregar e limpar dados em um notebook do Colab Enterprise com a ajuda do Gemini Code Assist

O Google Cloud oferece algumas maneiras principais de trabalhar com notebooks do Jupyter. Vamos usar a mais nova oferta do Google, o Colab Enterprise. Algumas pessoas já conhecem o produto Colab do Google, usado com frequência por indivíduos e organizações que querem testar notebooks Jupyter em um ambiente sem custo financeiro. O Colab Enterprise é uma oferta comercial do Google Cloud totalmente integrada ao restante dos produtos de nuvem do Google e que aproveita ao máximo os recursos de segurança e conformidade do ambiente do GCP.

Um dos recursos oferecidos pelo Colab Enterprise é a integração com o Gemini Code Assist do Google. O Code Assist pode ser usado em vários editores de código diferentes e oferecer conselhos, além de sugestões inline perfeitas enquanto você programa. Vamos aproveitar esse assistente generativo enquanto organizamos os dados da receita.

Use a pesquisa para acessar o Colab Enterprise e clique em Criar notebook. Se você receber uma oferta para testar novos recursos do Colab, dispense-a. Para ativar o tempo de execução, a capacidade de computação por trás do notebook, clique em Conectar no canto superior direito do novo notebook.
Clique em Arquivo > Renomear para renomear o notebook como Data Wrangling.
Clique em + Texto para criar uma nova caixa de texto e use a seta para cima para movê-la de modo que seja a primeira célula da página.

Edite a caixa de texto e insira:

# Data Wrangling

Import the Pandas library

No bloco de código abaixo do bloco de texto que você acabou de criar, comece a digitar imp. O Gemini Code Assist vai sugerir o restante da importação em cinza. Pressione Tab para aceitar a sugestão.
```
import pandas as pd
```

Abaixo da caixa de código de importação, crie outra caixa de texto e insira:

Create a Pandas DataFrame from: gs://labs.roitraining.com/labs/recipes/recipe_dataset.csv. View the first few records.

Crie e edite outro bloco de código. De novo, comece a digitar df = e examine o código gerado pelo Gemini Code Assist. Se você vir uma lista suspensa de preenchimento automático de palavras-chave do Python sobre a sugestão gerada, pressione "Escape" para ver o código sugerido em cinza claro. Pressione Tab novamente para aceitar a sugestão. Se a sugestão não tiver a chamada de função head(), adicione-a.
```
df = pd.read_csv('gs://labs.roitraining.com/labs/recipes/recipe_dataset.csv')
df.head()
```
Clique na primeira célula de código, onde você importou o Pandas, e use o menu Comandos ou o teclado para executar a célula selecionada. No teclado, shift+enter executa a célula e muda o foco para a próxima, criando uma se necessário. Aguarde a execução da célula antes de continuar.OBSERVAÇÃO: você verá [ ] à esquerda quando uma célula não tiver sido executada. Enquanto uma célula está sendo executada, você vê uma animação girando. Quando a célula terminar, um número vai aparecer, como [13].
Execute a célula que carrega o CSV no DataFrame. Aguarde o carregamento do arquivo e examine as cinco primeiras linhas de dados. Esses são os dados de receitas que vamos carregar no BigQuery e que usaremos para fundamentar nosso gerador de receitas.
Crie um novo bloco de código e insira o comentário abaixo. Depois de digitar o comentário, vá para a próxima linha de código e você vai receber a sugestão df.columns. Aceite e execute a célula.
```
# List the current DataFrame column names
```
Acabamos de demonstrar que você tem duas opções de como receber ajuda do Gemini Code Assist em um notebook Jupyter: células de texto acima das células de código ou comentários dentro da própria célula de código. Os comentários em células de código funcionam bem em notebooks Jupyter, mas essa abordagem também funciona em qualquer outro ambiente de desenvolvimento integrado que ofereça suporte ao Gemini Code Assist do Google.
Vamos fazer uma pequena revisão dos dados das colunas. Renomeie a coluna Unnamed: 0 para id e link para uri. Use a opção de comando > técnicas de código para criar o código e execute a célula quando estiver satisfeito.
```
# Rename the column 'Unnamed: 0' to 'id' and 'link' to 'uri'
df.rename(columns={'Unnamed: 0': 'id', 'link': 'uri'}, inplace=True)
```
Remova as colunas source e NER e use head() para conferir as primeiras linhas. De novo, peça ajuda ao Gemini. Execute as duas últimas linhas e analise os resultados.
```
# Remove the source and NER columns
df.drop(columns=['source', 'NER'], inplace=True)
df.head()
```
Vamos ver quantos registros há no nosso conjunto de dados. Comece com a técnica de comando que preferir e veja se o Gemini pode ajudar a gerar o código.
```
# Count the records in the DataFrame
df.shape # count() will also work
```
2,23 milhões de registros são provavelmente mais receitas do que temos tempo para fazer. O processo de indexação no Agent Builder provavelmente levaria muito tempo para o exercício de hoje. Como um compromisso, vamos selecionar 150.000 receitas e trabalhar com elas. Use a abordagem de comando > código para pegar a amostra e armazená-la em um novo DataFrame chamado dfs (s de pequeno).
```
# Sample out 150,000 records into a DataFrame named dfs
dfs = df.sample(n=150000)
```
Os dados de origem da receita estão prontos para serem carregados no BigQuery. Antes de fazer o carregamento, acesse o BigQuery e prepare um conjunto de dados para armazenar a tabela. No console do Google Cloud, use a caixa de pesquisa para acessar o BigQuery. Clique com o botão direito do mouse em BigQuery e abra em uma nova guia do navegador.
Se ele ainda não estiver visível, abra o painel de conversa com a IA do Gemini usando o logotipo do Gemini no canto superior direito do console do Cloud. Se for necessário ativar a API de novo, pressione "Ativar" ou atualize a página. Execute o comando: What is a dataset used for in BigQuery? Depois de analisar a resposta, pergunte: How can I create a dataset named recipe_data using the Cloud Console? Compare os resultados com as próximas etapas.
No painel do Explorador do BigQuery, clique no menu de três pontos Ver ações ao lado do ID do projeto. Em seguida, selecione Criar conjunto de dados.
Forneça o conjunto de dados e o ID de recipe_data. Deixe o tipo de local como US e clique em Criar conjunto de dados. Se você receber um erro informando que o conjunto de dados já existe, basta continuar.Com o conjunto de dados criado no BigQuery, volte ao notebook e faça a inserção.
Volte para o notebook de tratamento de dados no Colab Enterprise. Em uma nova célula de código, crie uma variável chamada project_id e use-a para armazenar o ID do projeto atual. Na parte de cima à esquerda destas instruções, abaixo do botão "Encerrar laboratório", você encontra o ID do projeto atual. Ela também está na página inicial do Console do Cloud, se preferir. Atribua o valor à variável project_id e execute a célula.
```
# Create a variable to hold the current project_id
project_id='YOUR_PROJECT_ID'
```
Use a abordagem "comando > código" para criar um bloco de código que vai inserir o DataFrame dfs em uma tabela chamada recipes no conjunto de dados recipe_data que acabamos de criar. Execute a célula.
```
dfs.to_gbq(destination_table='recipe_data.recipes', project_id=project_id, if_exists='replace')
```

7. Criar um app de pesquisa no Vertex AI Agent Builder para o gerador de receitas

Excelente! Agora que criamos nossa tabela de dados de receitas, vamos usá-la para criar uma fonte de dados fundamentada para nosso gerador de receitas. A abordagem que vamos usar é semelhante à que usamos para nosso chatbot de receitas. Vamos usar o Vertex AI Agent Builder para criar um repositório de dados e usá-lo como a fonte de verdade para um app de pesquisa.

Se quiser, peça ao Gemini no console do Google Cloud para lembrar as etapas de criação de um app de pesquisa do Agent Builder ou siga as etapas listadas abaixo.

Use a pesquisa para acessar o Agent Builder. Abra Repositórios de dados e Criar repositório de dados. Desta vez, selecione o tipo de repositório de dados do BigQuery.
Na célula de seleção de tabela, pressione Procurar e pesquise recipes. Selecione o botão de opção ao lado da tabela. Se você encontrar receitas de outros projetos qwiklabs-gcp-..., selecione a que pertence a você.OBSERVAÇÃO: se você clicar em recipes em vez de selecionar o botão de opção ao lado, uma nova guia será aberta no navegador e você será direcionado à página de visão geral da tabela no BigQuery. Basta fechar a guia do navegador e selecionar o botão de opção no Agent Builder.
Examine, mas não mude as outras opções padrão. Depois, clique em Continuar.
Na página de revisão do esquema, examine as configurações padrão iniciais, mas não mude nada. Continuar
Nomeie o repositório de dados como recipe-data. Edite o ID do DataStore e defina como recipe-data-id. Crie o repositório de dados.
Navegue até Apps usando o menu de navegação à esquerda e clique em Criar um novo app.
Clique em Criar no card Pesquisar no site. Nomeie o app como recipe-search e clique em EDITAR para definir o ID como recipe-search-id. Defina o nome da empresa como Google e clique em Continuar.
Desta vez, verifique as fontes de dados recipe-data. Crie o app.

Vai levar um tempo para que a tabela do banco de dados seja indexada. Enquanto isso, vamos testar a nova tela de dados do BigQuery e ver se encontramos uma ou duas receitas interessantes.

Use a caixa de pesquisa para acessar o BigQuery. Na parte de cima do BigQuery Studio, clique na seta para baixo ao lado da guia mais à direita e selecione Tela de dados. Defina a região como us-central1.
Clique em Pesquisar dados. Na caixa de pesquisa da tela de dados, procure recipes, pressione Enter/Return para pesquisar e clique no botão Adicionar à tela ao lado do nome da tabela.
Uma representação visual da sua tabela de receitas será carregada na tela de dados do BigQuery. É possível analisar o esquema da tabela, visualizar os dados e examinar outros detalhes. Abaixo da representação da tabela, clique em Consulta.
A tela vai carregar uma caixa de diálogo de consulta do BigQuery mais ou menos típica com uma adição: acima da janela de consulta, há uma caixa de texto que você pode usar para pedir ajuda ao Gemini. Vamos ver se encontramos algumas receitas de bolo na nossa amostra. Execute o seguinte comando (digitando o texto e pressionando Enter/Return para acionar a geração de SQL):
```
Please select the title and ingredients for all the recipes with a title that contains the word cake.
```
Analise o SQL gerado. Quando terminar, clique em Executar.
Nada mal! Teste alguns outros comandos e consultas antes de continuar. Ao testar, use comandos menos específicos para ver o que funciona e o que não funciona. Por exemplo, este comando:
```
Do I have any chili recipes?
```
(Não se esqueça de executar a nova consulta) Retornou uma lista de receitas de chili, mas deixou de fora os ingredientes até que eu modifiquei para:
```
Do I have any chili recipes?  Please include their title and ingredients.
```
(Sim, eu digo "por favor" quando dou um comando. Minha mãe ficaria muito orgulhosa.) Notei que uma receita de chili continha cogumelos, e quem quer isso em um chili? Pedi ajuda ao Gemini para excluir essas receitas.
```
Do I have any chili recipes?  Please include their title and ingredients, and ignore any recipes with mushrooms as an ingredient.
```

8. Abrir editor do Cloud Shell

Acesse o editor do Cloud Shell.
Se o terminal não aparecer na parte de baixo da tela, abra-o:
- Clique no menu de navegação .
- Clique em Terminal.
- Clique em Novo Terminal.

No terminal, defina o projeto com este comando:

Formato:
```
gcloud config set project [PROJECT_ID]
```

Exemplo:

gcloud config set project lab-project-id-example

Se você não se lembrar do ID do projeto:
- Para listar todos os IDs de projeto, use:
```
gcloud projects list | awk '/PROJECT_ID/{print $2}'
```

Se for preciso autorizar, clique em Autorizar para continuar.
Você vai receber esta mensagem:
```
Updated property [core/project].
```
Se você vir um WARNING e for perguntado Do you want to continue (Y/N)?, provavelmente inseriu o ID do projeto incorretamente. Pressione N, Enter e tente executar o comando gcloud config set project novamente.

9. Ativar APIs

No terminal, ative as APIs:

gcloud services enable \
  compute.googleapis.com \
  sqladmin.googleapis.com \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  networkconnectivity.googleapis.com \
  servicenetworking.googleapis.com \
  cloudaicompanion.googleapis.com

Se for preciso autorizar, clique em Autorizar para continuar. Clique para autorizar o Cloud Shell

Esse comando pode levar alguns minutos para ser concluído, mas vai gerar uma mensagem de sucesso semelhante a esta:

Operation "operations/acf.p2-73d90d00-47ee-447a-b600" finished successfully.

10. Estruturar o aplicativo da Web principal em Python e Streamlit com a ajuda do Gemini

Com os dois repositórios de dados do Vertex AI Agent Builder indexados e os apps de pesquisa quase prontos para serem lançados, vamos criar nosso aplicativo da Web.

Vamos usar o Gemini Code Assist enquanto trabalhamos. Para mais informações sobre como usar o Gemini Code Assist no Visual Studio Code, consulte a documentação aqui.

No terminal do editor do Cloud Shell, execute este comando para clonar o repositório do app de receitas.
```
git clone https://github.com/haggman/recipe-app
```
Execute este comando para abrir a pasta do aplicativo no editor do Cloud Shell.
```
cloudshell open-workspace recipe-app/
```
Antes de explorar a pasta clonada e começar a trabalhar no aplicativo da Web, precisamos fazer login no Google Cloud com o plug-in Cloud Code do editor e ativar o Gemini. Vamos fazer isso agora. Na parte de baixo à esquerda do editor, clique em Cloud Code - Fazer login. Se o link não aparecer, aguarde um minuto e verifique novamente.
A janela do terminal vai mostrar um URL longo. Abra o URL no navegador e siga as etapas para conceder ao Cloud Code acesso ao seu ambiente do Google Cloud. Na caixa de diálogo final, Copie o código de verificação e cole-o de volta na janela do terminal em espera na guia do navegador do editor do Cloud Shell.
Depois de alguns instantes, o link do Cloud Code no canto inferior esquerdo do editor vai mudar para Cloud Code - Sem projeto. Clique no novo link para selecionar um projeto. A paleta de comandos vai abrir na parte de cima do editor. Clique em Selecionar um projeto na nuvem do Google e escolha seu projeto. Depois de alguns instantes, o link no canto inferior esquerdo do editor será atualizado para mostrar o ID do projeto. Isso indica que o Cloud Code foi anexado ao projeto de trabalho.
Com o Cloud Code conectado ao seu projeto, agora é possível ativar o Gemini Code Assist. No canto inferior direito da interface do editor, clique no logotipo riscado do Gemini. O painel do Gemini Chat vai abrir à esquerda do editor. Clique em Selecionar um projeto do Google Cloud. Quando a paleta de comandos abrir, selecione seu projeto. Se você seguiu as etapas corretamente (e o Google não mudou nada), uma janela de conversa no Gemini ativa vai aparecer.
Excelente! Com o terminal, a conversa no Gemini e as configurações do Cloud Code definidos, abra a guia Explorer e reserve alguns minutos para explorar os arquivos no projeto atual.

No Explorer, abra o arquivo requirements.txt para edição. Mude para o painel de chat do Gemini e pergunte:

From the dependencies specified in the requirements.txt file, what type of application are we building?

Então, estamos criando um aplicativo da Web interativo usando Python e Streamlit que interage com a Vertex AI e o Discovery Engine. Por enquanto, vamos nos concentrar nos componentes do aplicativo da Web. Como o Gemini diz, o Streamlit é um framework para criar aplicativos da Web orientados a dados em Python. Agora peça o seguinte:
```
Does the current project's folder structure seem appropriate for a Streamlit app?
```
É aqui que o Gemini costuma ter problemas. O Gemini pode acessar o arquivo aberto no editor, mas não consegue ver todo o projeto. Tente perguntar:
```
Given the below, does the current project's file and folder structure seem appropriate for a Streamlit app?
- build.sh
- Home.py
- requirements.txt
- pages
-- Cooking_Advice.py
-- Recipe_Search.py
```
Quer uma resposta melhor?
Vamos coletar mais informações sobre o Streamlit:
```
What can you tell me about Streamlit?
```
Legal, assim podemos ver que o Gemini está oferecendo uma boa visão geral, incluindo prós e contras.
Se quiser saber os contras, pergunte:
```
What are the major downsides or shortcomings?
```
Observe que não precisamos dizer "do Streamlit" porque a conversa no Gemini é conversacional (vários turnos). O Gemini sabe do que estamos falando porque estamos em uma sessão de chat. Se quiser limpar o histórico de conversa no Gemini, use o ícone de lixeira na parte de cima da janela de chat de código do Gemini.

11. Implantar o aplicativo da Web no Cloud Run

Excelente, temos nossa estrutura principal de aplicativo, mas tudo vai funcionar? Melhor ainda, onde devemos hospedar no Google Cloud?

Na conversa no Gemini, pergunte:

If I containerize this application, what compute technologies in Google Cloud would be best for hosting it?

Se você não estiver trabalhando no seu ambiente de desenvolvimento integrado, também poderá usar o Google Cloud Assist. Abra o console do Google Cloud, o Gemini Cloud Assist e pergunte:
```
If I have a containerized web application, where would be the best place to run it in Google Cloud?
```
Os dois conjuntos de conselhos eram iguais? Você concorda ou discorda de alguma das dicas? O Gemini é um assistente de IA generativa e, assim como um assistente humano, você nem sempre vai concordar com tudo o que ele diz. No entanto, ter esse assistente sempre ao seu lado enquanto você trabalha no Google Cloud e no editor de código pode aumentar muito sua eficiência.
Para um aplicativo da Web conteinerizado sem estado e de curta duração, o Cloud Run seria uma ótima opção. Na conversa no Gemini no editor de código, tente o comando:
```
What steps would be required to run this application in Cloud Run?
```
Parece que a primeira coisa que precisamos fazer é criar um Dockerfile. Usando o editor, crie um arquivo chamado Dockerfile na raiz da pasta do projeto. Não coloque acidentalmente na pasta pages. Abra o arquivo para edição.
Vamos usar o painel lateral de conversa no Gemini para criar nosso Dockerfile. Use um comando como o abaixo. Quando os resultados forem exibidos no chat, use o + ao lado do ícone de cópia, logo acima do Dockerfile sugerido, para inserir o código sugerido no Dockerfile.
```
Create a Dockerfile for the application in the current folder. The dependencies are defined in requirements.txt and I want you to use the Python 3 slim bookworm base image.
```
O Gemini nem sempre retorna a mesma resposta ao mesmo comando. Na primeira vez que pedi um Dockerfile ao Gemini, recebi exatamente o arquivo que vou sugerir para você. Acabei de receber a sugestão:
```
# Base image
FROM python:3-bookworm-slim

# Set working directory
WORKDIR /app

# Install dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    libpq-dev \
    gcc \
    python3-dev \
    && rm -rf /var/lib/apt/lists/*

# Install pip and virtualenv
RUN pip install --upgrade pip virtualenv

# Create virtual environment
RUN python3 -m venv venv

# Activate virtual environment
WORKDIR /app/venv/bin
RUN . activate

# Install Streamlit and libraries from requirements.txt
RUN pip install -r requirements.txt

# Copy application files
COPY . /app

# Expose port 8501 for Streamlit
EXPOSE 8501

# Start Streamlit app
CMD ["streamlit", "run", "main.py"]
```
Esse é um Dockerfile incrível. Eu simplificaria um pouco. Não precisamos da seção "apt-get", porque tudo o que é necessário para o Python já está na nossa imagem de base. Além disso, usar um ambiente virtual em um contêiner Python é um desperdício de espaço. Portanto, remova isso. O comando "expose" não é estritamente necessário, mas não há problema em usá-lo. Além disso, ele está tentando iniciar main.py, que eu não tenho.

Na pasta recipe-app, crie um arquivo chamado Dockerfile e cole este conteúdo:

FROM python:3.11-slim-bookworm

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir --upgrade pip && \
    pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["streamlit", "run", "Home.py"]

O Gemini pode operar na janela de chat, mas também pode trabalhar diretamente no arquivo de código usando comentários, como fizemos no notebook de tratamento de dados. Ele também pode ser invocado usando Control+i no Windows ou Command+i no Mac. Clique em algum lugar no Dockerfile e ative o Gemini usando o comando apropriado Command+i / Control+i.
No prompt, insira o comando abaixo. Examine e aceite a mudança.
```
Please comment the current file.
```
Não é demais? Quantas vezes você teve que trabalhar com o código de outra pessoa e perdeu tempo entendendo o trabalho sem comentários dela antes de começar a fazer suas mudanças? O Gemini pode ajudar!
Agora pergunte ao Gemini como usar o Cloud Run para criar e implantar uma nova imagem chamada recipe-web-app com base no Dockerfile na pasta atual.
```
How could I use gcloud to build a new Cloud Run service named recipe-web-app from the current directory?
```

Vamos criar e implantar nosso aplicativo. Na janela do terminal, execute o comando gcloud run deploy.

gcloud run deploy recipe-web-app \
    --allow-unauthenticated \
    --source=. \
    --region=us-central1 \
    --port=8501

Se aparecer uma solicitação para criar um repositório do Artifact Registry, pressione enter/return.

Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository
named cloud-run-source-deploy in region us-central1 will be created.

Do you want to continue (Y/n)?

Se você acompanhar o processo de build, primeiro ele vai criar o repositório do Docker do Artifact Registry. Em seguida, ele usa o Cloud Build para criar a imagem do contêiner com base no Dockerfile na pasta local. Por fim, a imagem do Docker será implantada em um novo serviço do Cloud Run. No final do script, você vai receber um URL de teste do Cloud Run para usar.

Abra o link retornado em uma nova guia do navegador. Reserve um momento para explorar a estrutura e as páginas do aplicativo. Ótimo, agora precisamos conectar nossa funcionalidade de IA generativa.

12. Conectar a página "Cooking Advice" ao app do Agent Builder "cookbook-search"

Temos o framework do aplicativo da Web em execução, mas precisamos conectar as duas páginas de trabalho aos dois apps de pesquisa do Vertex AI Agent Builder. Vamos começar com "Dicas de culinária".

Deixe a guia do editor do Cloud Shell aberta. No console do Google Cloud, use a pesquisa para navegar até Chat na Vertex AI.
No painel da página de configurações à direita, defina o modelo como gemini-1.5-flash-002. Deslize o limite de tokens de saída até o máximo para que o modelo possa retornar respostas mais longas, se necessário. Abra as Configurações do Filtro de segurança. Defina as opções "Discurso de ódio", "Conteúdo sexualmente explícito" e "Assédio" como Bloquear alguns. Defina "Conteúdo perigoso" como Bloquear poucos e clique em Salvar. Estamos definindo o conteúdo perigoso como um pouco mais baixo porque falar sobre facas e cortes pode ser mal interpretado pelo Gemini como violência.
Deslize o botão para ativar o Embasamento e clique em Personalizar. Defina a origem de embasamento como Pesquisa da Vertex AI e use o seguinte caminho para o repositório de dados. Mude YOUR_PROJECT_ID para o ID do projeto encontrado perto do botão "Encerrar laboratório" nestas instruções e Salve as configurações de embasamento.
```
projects/YOUR_PROJECT_ID/locations/global/collections/default_collection/dataStores/old-cookbooks-id
```
OBSERVAÇÃO: se você receber um erro, não mudou o ID do projeto para o ID real ou perdeu a etapa em que mudou o ID do repositório de dados do Agent Builder de receitas antigas. Verifique o ID real do repositório de dados em Agent Builder > Repositórios de dados > old-cookbooks.
Teste algumas mensagens de chat. Talvez comece com o seguinte. Se quiser, tente mais alguns.
```
How can I tell if a tomato is ripe?
```
O modelo funciona. Agora vamos testar o código. Clique em Limpar conversa para que nossas conversas não façam parte do código e clique em Receber código.
Na parte de cima da janela de código, clique em Abrir notebook para testar e aperfeiçoar o código no Colab Enterprise antes de integrá-lo ao app.
Reserve alguns minutos para se familiarizar com o código. Vamos fazer algumas mudanças para adaptar o código ao que queremos. Antes de começar, execute a primeira célula de código para se conectar à computação e instalar o SDK do AI Platform. Depois que o bloco for executado, você vai receber um aviso para reiniciar a sessão. Vá em frente e crie as chaves.
Acesse o código que extraímos do Vertex AI Studio. Mude o nome do método multiturn_generate_content para start_chat_session.
Role a tela até a chamada de método model = GenerativeModel(. O código atual define generation_config e safety_settings, mas não os usa. Modifique a criação do GenerativeModel para que ela se pareça com:
```
model = GenerativeModel(
    "gemini-1.5-flash-002",
    tools=tools,
    generation_config=generation_config,
    safety_settings=safety_settings,
)
```

Por fim, adicione uma linha final ao método, logo abaixo de chat = model.start_chat(), para que a função retorne o objeto chat. A função concluída vai ficar assim.NÃO COPIE este código para seu notebook. Ele está aqui apenas como uma verificação de integridade.

def start_chat_session():
    vertexai.init(project="qwiklabs-gcp-02-9a7298ceaaec", location="us-central1")
    tools = [
        Tool.from_retrieval(
            retrieval=grounding.Retrieval(
                source=grounding.VertexAISearch(datastore="projects/qwiklabs-gcp-02-9a7298ceaaec/locations/global/collections/default_collection/dataStores/old-cookbooks-id"),
            )
        ),
    ]
    model = GenerativeModel(
        "gemini-1.5-flash-002",
        tools=tools,
        generation_config=generation_config,
        safety_settings=safety_settings,
    )
    chat = model.start_chat()
    return chat

Role até a parte de baixo da célula de código e mude a linha final que chama a função antiga para que ela chame o novo nome da função e armazene o objeto retornado em uma variável chat. Quando estiver satisfeito com as mudanças, execute a célula.
```
chat = start_chat_session()
```
Crie uma célula de código e adicione o comentário # Use chat to invoke Gemini and print out the response. Vá para a próxima linha e digite resp. O Gemini vai preencher automaticamente o bloco para você. Atualize o comando para How can I tell if a tomato is ripe?. Executar a célula
```
response = chat.send_message("How can I tell if a tomato is ripe?")
print(response)
```
Essa é a resposta, mas a parte que realmente queremos é o campo text aninhado. Modifique o bloco de código para imprimir apenas essa seção, assim:
```
response = chat.send_message("How can I tell if a tomato is ripe?")
print(response.candidates[0].content.parts[0].text)
```
Agora que temos um código de chat funcional, vamos integrá-lo ao aplicativo da Web. Copie todo o conteúdo da célula de código que cria a função start_chat_session. Não vamos precisar da célula de teste. Se você clicar na célula, poderá clicar no menu de três pontos no canto superior direito e copiar de lá.
Mude para a guia do editor do Cloud Shell e abra pages\Cooking_Advice.py para edição.

Encontre o comentário:

#
# Add the code you copied from your notebook below this message
#

Cole o código copiado logo abaixo do comentário Adicione o código. Ótimo, agora temos a seção que impulsiona o mecanismo de chat com uma chamada fundamentada para o Gemini. Agora vamos integrar ao Streamlit.

Localize a seção de código comentado diretamente abaixo do comentário:

#
# Here's the code to setup your session variables
# Uncomment this block when instructed
#

Remova a marca de comentário dessa seção de código (até a próxima seção Setup done, let's build the page UI) e explore. Ele cria ou recupera as variáveis de sessão de chat e histórico.
Em seguida, precisamos integrar o histórico e a funcionalidade de chat à interface. Role o código até localizar o comentário abaixo.
```
#
# Here's the code to create the chat interface
# Uncomment the below code when instructed
#
```
Remova a marca de comentário do restante do código abaixo e reserve um momento para analisá-lo. Se quiser, destaque e peça para o Gemini explicar a funcionalidade.
Excelente. Agora vamos criar e implantar o aplicativo. Quando o URL voltar, inicie o aplicativo e teste a página do Cooking Advisor. Talvez você possa perguntar sobre tomates maduros ou se o bot sabe uma boa maneira de preparar couve-de-bruxelas.
```
gcloud run deploy recipe-web-app \
    --allow-unauthenticated \
    --source=. \
    --region=us-central1 \
    --port=8501
```

Isso é muito bom. Seu consultor pessoal de culinária com IA :-)

13. (Opcional) Conecte a página de pesquisa de receitas ao app do Agent Builder de pesquisa de receitas

Quando conectamos a página "Dicas de culinária" à fonte embasada, usamos a API Gemini diretamente. Para a Pesquisa de receitas, vamos nos conectar diretamente ao app de pesquisa do Vertex AI Agent Builder.

No editor do Cloud Shell, abra a página pages/Recipe_Search.py para edição. Investigue a estrutura da página.
Na parte de cima do arquivo, defina o ID do projeto.
Examine a função search_sample. Esse código vem mais ou menos diretamente da documentação do Discovery Engine neste link. Você pode encontrar uma cópia funcional neste notebook.A única mudança que fiz foi retornar o response.results em vez de apenas os resultados. Sem isso, o tipo de retorno é um objeto projetado para paginar os resultados, algo que não precisamos para nosso aplicativo básico.
Role até o final do arquivo e remova o comentário de toda a seção abaixo de Here are the first 5 recipes I found.
Destaque toda a seção que você acabou de remover o comentário e abra o chat do Gemini Code. Pergunte ao Explain the highlighted code. Se você não selecionar nada, o Gemini poderá explicar o arquivo inteiro. Se você destacar uma seção e pedir ao Gemini para explicar, comentar ou melhorar, ele vai fazer isso.Leia a explicação com atenção. Usar um notebook do Colab Enterprise é uma ótima maneira de conhecer as APIs Gemini antes de integrá-las ao seu aplicativo. Isso é especialmente útil para explorar algumas das APIs mais recentes que podem não estar tão bem documentadas quanto poderiam.
Na janela do terminal do editor, execute build.sh para implantar o aplicativo final. Aguarde até que a nova versão seja implantada antes de passar para a próxima etapa.

14. (Opcional) Conheça o aplicativo final

Reserve alguns minutos para conhecer o aplicativo final.

No console do Google Cloud, use a pesquisa para acessar Cloud Run e clique em recipe-web-app.
Localize o URL de teste do aplicativo (na parte de cima) e abra em uma nova guia do navegador.
A página inicial do aplicativo vai aparecer. Observe o layout e a navegação básicos fornecidos pelo Streamlit, com os arquivos Python da pasta pages exibidos como opções de navegação e o Home.py carregado como a página inicial. Acesse a página Dicas de culinária.
Depois de alguns instantes, a interface de chat vai aparecer. Mais uma vez, observe o layout principal fornecido pelo Streamlit.

Faça algumas perguntas relacionadas a culinária e veja como o bot funciona. Algo assim:

Do you have any advice for preparing broccoli?

How about a classic chicken soup recipe?

Tell me about meringue.

Agora vamos encontrar uma ou duas receitas. Acesse a página de pesquisa de receitas e faça algumas pesquisas. Algo assim:
```
Chili con carne

Chili, corn, rice

Lemon Meringue Pie

A dessert containing strawberries
```

15. Parabéns!

Você criou um aplicativo usando os aplicativos do Vertex AI Agent Builder. Ao longo do caminho, você conheceu o Gemini Cloud Assist, o Gemini Code Assist e os recursos de linguagem natural para SQL da tela de dados do BigQuery. Ótimo trabalho!

Limpar

O Cloud SQL não tem um nível sem custo financeiro e vai cobrar se você continuar usando o serviço. É possível excluir seu projeto na nuvem para evitar cobranças adicionais.

O Cloud Run não gera custos quando o serviço não está em uso, mas você ainda pode receber cobranças pelo armazenamento da imagem do contêiner no Artifact Registry. A exclusão do projeto na nuvem interrompe o faturamento de todos os recursos usados nele.

Se quiser, exclua o projeto:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Você também pode excluir recursos desnecessários do disco do Cloud Shell. Você pode:

Exclua o diretório do projeto do codelab:
```
rm -rf ~/task-app
```
Aviso: Não é possível desfazer a próxima ação. Se você quiser excluir tudo no Cloud Shell para liberar espaço, exclua todo o diretório inicial. Tenha cuidado para que tudo o que você quer manter seja salvo em outro lugar.
```
sudo rm -rf $HOME
```