Esta página foi traduzida pela API Cloud Translation.

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 linguagem natural para recursos 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 no Cloud Storage e no 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 vai conter 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 conselhos culinários e responder a perguntas relacionadas a culinária. O 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ê ficar preso em algum código neste exercício, as soluções para todos os arquivos de código estão localizadas 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 no Vertex AI Agent Builder para o chatbot de conselhos culinários
Carregar e limpar dados em um bloco 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
Defina o aplicativo da Web principal do Python e do Streamlit com um pouco de ajuda do Gemini
Implantar o aplicativo da Web no Cloud Run
Conectar a página "Cooking Advice" ao app do Agent Builder para pesquisa de livros de receitas
(Opcional) Conecte a página "Pesquisa de receitas" ao app de pesquisa de receitas do Agent Builder
(Opcional) Conheça o aplicativo final

2. Pré-requisitos

Se você ainda não tem uma Conta do Google, crie uma.
- Use uma conta pessoal em vez de uma conta de trabalho ou escolar. 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 deve custar menos de US $1 em recursos do Cloud.
- Siga as etapas no final deste laboratório para excluir recursos e evitar cobranças.
- Novos usuários estão qualificados para o teste sem custo financeiro de US$300.
- Vai participar de um evento virtual de laboratório prático? Talvez um crédito de US$5 esteja disponível.
Crie um novo projeto ou escolha reutilizar um projeto atual.
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 teste 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 na criação, configuração e monitoramento da infraestrutura 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 e selecione Pergunte ao Gemini ou Pergunte ao Gemini no console do Cloud.
Role até a seção "APIs obrigatórias" da página e ative a API Gemini para Google Cloud.
Se a interface de chat não aparecer imediatamente, clique em Iniciar a conversa. Comece pedindo para o Gemini explicar alguns dos benefícios do uso do editor do Cloud Shell. Reserve alguns minutos para conferir a resposta gerada.
Em seguida, pergunte sobre os benefícios do Agente Builder e como ele pode ajudar a fundamentar as respostas generativas.
Por fim, vamos fazer uma comparação. Na janela de chat do Gemini no 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 no Vertex AI Agent Builder para o chatbot de conselhos culinários

O site que estamos criando terá uma página de conselhos de culinária com um chatbot projetado para ajudar os usuários a encontrar respostas para perguntas relacionadas a culinária. Ele será alimentado pelo 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 verdade que o Gemini usa para 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 você receber uma caixa pop-up sobre a necessidade de ativar a API Vertex AI, ative. Quando as APIs estiverem ativadas, você poderá passar para a próxima etapa.
Use a pesquisa para navegar até o Agent Builder e clique em Continuar e ativar a API.
Como o Gemini sugeriu em nosso conselho anterior, a criação de um app de pesquisa no Agent Builder começa com a criação de uma origem de dados oficial. Quando o usuário faz uma pesquisa, o Gemini entende a pergunta e como compor respostas inteligentes, mas procura a fonte com base nas informações usadas nessa resposta, em vez de usar o conhecimento inato.No menu à esquerda, navegue até Armazenamentos de dados e Criar armazenamento de dados.
Os livros de receitas de domínio público que estamos usando para fundamentar nossa página de conselhos de culinária estão em um bucket do Cloud Storage em um projeto externo. Selecione o tipo de origem do Cloud Storage.
Analise, mas não altere as opções padrão relacionadas ao tipo de informação que estamos importando. Deixe o tipo de importação definido como Pasta e use o caminho do bucket: labs.roitraining.com/labs/old-cookbooks. Em seguida, clique em Continuar.
Nomeie o repositório de dados: old-cookbooks. Clique em EDIT e mude o ID para old-cookbooks-id e Crie o repositório de dados.

O Vertex AI Agent Builder oferece suporte a vários tipos de apps, e a Data Store 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 orientados pelo Dataflow. Os apps de recomendação ajudam a criar mecanismos de recomendação melhores. Os apps de agente são usados para criar agentes com base na IA generativa. No final, o Agente provavelmente será mais útil para o que queremos fazer, mas, como o produto está em visualização, 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 seu 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 Agente de criação vai levar mais de cinco minutos para indexar os milhares de páginas contidas nos 70 livros de receitas que fornecemos. Enquanto isso, vamos carregar e limpar alguns dados do banco de dados de receitas para o gerador de receitas.

6. Carregar e limpar dados em um bloco 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 oferta mais recente do Google, o Colab Enterprise. Alguns de vocês podem conhecer o produto Colab do Google, que é comumente usado por indivíduos e organizações que gostariam de experimentar notebooks do 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 compliance do ambiente do GCP.

Um dos recursos do 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 oferece conselhos e sugestões inline perfeitas enquanto você programa. Vamos aproveitar esse assistente generativo enquanto manipulamos os dados das receitas.

Use a pesquisa para navegar até o Colab Enterprise e clique em Criar bloco. Se você receber uma oferta para testar novos recursos do Colab, ignore. Para acessar o ambiente de execução, a capacidade de computação 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 para que ela 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. Novamente, 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 conferir o código sugerido em cinza claro. Pressione Tab para aceitar a sugestão. Se a sugestão não contiver 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 Commands 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 célula, criando uma se necessário. Aguarde a célula ser executada antes de continuar.OBSERVAÇÃO: [ ] vai aparecer à esquerda quando uma célula não tiver sido executada. Enquanto uma célula está sendo executada, você vai ver uma animação giratória. 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 usar 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, mova 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
```
Mostramos que você tem duas opções para receber ajuda do Gemini Code Assist em um notebook Jupyter: células de texto acima de células de código ou comentários dentro da própria célula de código. Os comentários dentro das células de código funcionam bem nos notebooks do Jupyter, mas essa abordagem também funciona em qualquer outro ambiente de desenvolvimento integrado com suporte ao Gemini Code Assist do Google.
Vamos fazer uma pequena limpeza de colunas. Renomeie a coluna Unnamed: 0 como id e link como uri. Use a sua escolha de comando > técnicas de código para criar o código e, em seguida, 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. Novamente, peça ajuda para o Gemini. Execute as duas últimas linhas e examine os resultados.
```
# Remove the source and NER columns
df.drop(columns=['source', 'NER'], inplace=True)
df.head()
```
Vamos conferir quantos registros há no nosso conjunto de dados. Novamente, comece com a técnica de solicitação escolhida 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 provavelmente são mais receitas do que temos tempo para fazer. O processo de indexação no Criador de agentes provavelmente vai demorar muito para nosso exercício de hoje. Como compromisso, vamos usar uma amostra de 150.000 receitas. Use a abordagem de comando > código para coletar a amostra e armazená-la em um novo DataFrame chamado dfs (s para pequeno).
```
# Sample out 150,000 records into a DataFrame named dfs
dfs = df.sample(n=150000)
```
Os dados da fonte de receitas estão prontos para serem carregados no BigQuery. Antes de fazer o carregamento, vamos acessar o BigQuery e preparar um conjunto de dados para armazenar nossa tabela. No console do Google Cloud, use a caixa de pesquisa para navegar até o BigQuery. Você pode clicar com o botão direito do mouse em BigQuery e abrir em uma nova guia do navegador.
Se ele ainda não estiver visível, abra o painel de conversa por chat da Gemini usando o logotipo da Gemini no canto superior direito do console do Cloud. Se você precisar ativar a API novamente, pressione "Ativar" ou atualize a página. Execute a instrução: What is a dataset used for in BigQuery? Depois de analisar a solicitação de resposta, How can I create a dataset named recipe_data using the Cloud Console? compare os resultados com as próximas etapas.
No painel "BigQuery Explorer", clique no menu de três pontos Ver ações ao lado do ID do projeto. Em seguida, selecione Criar conjunto de dados.
Informe o conjunto de dados e o ID de recipe_data. Deixe o tipo de local como EUA e 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 seu notebook e faça a inserção.
Volte para o notebook de manipulação de dados no Colab Enterprise. Em uma nova célula de código, crie uma variável com o nome project_id e use-a para armazenar o ID do projeto atual. Procure o ID do projeto atual no canto superior esquerdo dessas instruções, abaixo do botão "End Lab". Também está disponível 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 instrução > código para criar um bloco de código que insira o DataFrame dfs em uma tabela chamada recipes no conjunto de dados que acabamos de criar recipe_data. 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

Ótimo, com a tabela de dados de receitas criada, vamos usá-la para criar uma fonte de dados fundamentada para o gerador de receitas. A abordagem que vamos usar será semelhante à que usamos para o chatbot de culinária. Vamos usar o Vertex AI Agent Builder para criar um repositório de dados e, em seguida, usá-lo como a fonte de verdade de um app de pesquisa.

Se quiser, peça ao Gemini no Console do Google Cloud para lembrar você das etapas para criar um app de pesquisa do Criador de agentes ou siga as etapas 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 da 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 o que pertence a você.Observação: se você clicar em recipes em vez de selecionar o botão de opção ao lado dele, 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 Criador de agentes.
Examine, mas não mude o restante das opções padrão e clique em Continuar.
Na página de análise do esquema, examine as configurações padrão iniciais, mas não faça nenhuma alteração. Continuar
Nomeie o repositório de dados como recipe-data. Edite o ID do repositório de dados e defina-o 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 seu 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 Continue.
Desta vez, verifique as fontes de dados recipe-data. Crie o app.

Vai levar um tempo para a tabela do banco de dados ser indexada. Enquanto isso, vamos testar a nova tela de dados do BigQuery e ver se conseguimos encontrar 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 Canvas de dados. Defina a região como us-central1.
Clique em Pesquisar dados. Na caixa de pesquisa do painel de dados, pesquise recipes, pressione Enter/Return para pesquisar e clique no botão Adicionar ao painel ao lado do nome da tabela.
Uma representação visual da tabela de receitas será carregada na tela de dados do BigQuery. É possível conferir 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 pode ser usada para pedir ajuda ao Gemini. Vamos conferir se encontramos algumas receitas de bolo no nosso exemplo. 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.
```
Confira o SQL gerado. Quando terminar, execute a consulta.
Nada mal! Fique à vontade para testar outros comandos e consultas antes de continuar. Ao testar, use comandos menos específicos para saber o que funciona e o que não funciona. Por exemplo, esta solicitação:
```
Do I have any chili recipes?
```
(Não se esqueça de executar a nova consulta) Retorna uma lista de receitas de chili, mas deixa de fora os ingredientes até que eu modifique para:
```
Do I have any chili recipes?  Please include their title and ingredients.
```
(Sim, eu digo "por favor" quando peço. Minha mãe ficaria tão orgulhosa.) Percebi que uma receita de chili continha cogumelos, e quem quer isso no chili? Pedi para o Gemini me ajudar a 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 seu projeto com este comando:
- Formato:
```
gcloud config set project [PROJECT_ID]
```
- Exemplo:
```
gcloud config set project lab-project-id-example
```
- Se você não souber o ID do projeto:
  - É possível listar todos os IDs de projetos com:
```
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ê receber uma WARNING e receber uma solicitação Do you want to continue (Y/N)?, provavelmente inseriu o ID do projeto incorretamente. Pressione N, pressione 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. Defina o aplicativo da Web principal do Python e do Streamlit com um pouco de ajuda do Gemini

Com os repositórios de dados do Vertex AI Agent Builder indexados e os apps de pesquisa quase prontos, 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
```
Use esse comando para abrir a pasta do aplicativo no editor do Cloud Shell.
```
cloudshell open-workspace recipe-app/
```
Antes de analisarmos a pasta clonada e começarmos a trabalhar no nosso aplicativo da Web, precisamos fazer login no Google Cloud com o plug-in do Cloud Code do editor e ativar o Gemini. Vamos fazer isso agora. No canto inferior esquerdo do editor, clique em Cloud Code - Fazer login. Se você não encontrar o link, aguarde um minuto e confira novamente.
A janela do terminal vai mostrar um URL longo. Abra o URL no navegador e siga as etapas para conceder acesso do Cloud Code ao seu ambiente do Google Cloud. Na caixa de diálogo final, copie o código de verificação e cole-o na janela de 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 aparecer na parte de cima do editor. Clique em Selecionar um projeto do Google Cloud e escolha o 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 seu projeto.
Com o Cloud Code conectado ao seu projeto, agora você pode ativar o Gemini Code Assist. No canto inferior direito da interface do editor, clique no logotipo do Gemini riscado. O painel de chat do Gemini 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 chat ativa do Gemini vai aparecer.
Ótimo, com o terminal, o chat do Gemini e as configurações do Cloud Code configurados, abra a guia Explorer e dedique alguns minutos para conferir os arquivos do 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?

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 pergunte:
```
Does the current project's folder structure seem appropriate for a Streamlit app?
```
É aqui que o Gemini tende a ter problemas. O Gemini pode acessar o arquivo que você abriu no editor, mas não pode ver todo o projeto. Tente perguntar o seguinte:
```
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?
Confira mais informações sobre o Streamlit:
```
What can you tell me about Streamlit?
```
Ótimo, o Gemini está oferecendo uma boa visão geral, incluindo prós e contras.
Se você quiser explorar os contras, pergunte:
```
What are the major downsides or shortcomings?
```
Não precisamos dizer "do Streamlit" porque o Gemini Chat é conversacional (com vários turnos). O Gemini sabe sobre o que estamos falando porque estamos em uma sessão de chat. Se quiser limpar o histórico de conversas do Gemini, use o ícone de lixeira na parte de cima da janela de conversa com o código.

11. Implantar o aplicativo da Web no Cloud Run

Ótimo, nossa estrutura principal do aplicativo está em vigor, mas será que tudo vai funcionar? Melhor ainda, onde devemos hospedar no Google Cloud?

Na janela de chat do Gemini, pergunte:

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

Se você ainda não estava trabalhando no seu ambiente de desenvolvimento integrado, também pode usar o Google Cloud Assist. Abra o console do Google Cloud e, em seguida, abra 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 foram iguais? Você concorda ou discorda de algum dos conselhos? 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 seu editor de código pode aumentar muito a eficiência.
Para um aplicativo da Web conteinerizado sem estado de curta duração, o Cloud Run é uma ótima opção. Na janela de chat do 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-o acidentalmente na pasta páginas. Abra o arquivo para edição.
Vamos usar o painel lateral do chat do Gemini para criar nosso Dockerfile. Use uma instrução como a 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 não sempre retorna a mesma resposta para o mesmo comando. Na primeira vez que pedi um Dockerfile ao Gemini, recebi o arquivo exato que vou sugerir que você use. 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 muito grande. 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 pode ser usado. Além disso, ele está tentando iniciar o 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 ser operado pela janela de chat, mas também pode funcionar diretamente no arquivo de código usando comentários, como usamos no notebook "Data Wrangling". 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 Command + i / Control + i apropriado.
No prompt, insira o comando abaixo. Examine e aceite a mudança.
```
Please comment the current file.
```
Não é demais? Quantas vezes você já teve que trabalhar com o código de outra pessoa, apenas para perder tempo adquirindo um entendimento básico do trabalho sem comentários antes mesmo de começar a fazer mudanças. Gemini ao resgate!
Agora pergunte ao Gemini como usar o Cloud Run para criar e implantar uma nova imagem chamada recipe-web-app no Dockerfile da 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 você receber 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ê observar o processo de build, ele vai criar o repositório do Docker do Artifact Registry primeiro. Em seguida, ele usa o Cloud Build para criar a imagem do contêiner usando o 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 conferir a estrutura e as páginas do aplicativo. Ótimo, agora precisamos conectar a funcionalidade de IA generativa.

12. Conectar a página "Cooking Advice" ao app do Agent Builder para pesquisa de livros de receitas

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

Deixe a guia do editor do Cloud Shell aberta. No console do Google Cloud, use a pesquisa para navegar até o 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 para 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 "Discurso de ódio", "Conteúdo sexualmente explícito" e "Conteúdo de assédio" como Bloquear alguns. Defina "Conteúdos perigosos" como Bloquear alguns e Salvar. Estamos definindo o conteúdo perigoso um pouco mais baixo porque falar sobre facas e cortes pode ser 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 para o caminho do repositório de dados: Mude o valor de YOUR_PROJECT_ID para o ID do projeto encontrado perto do botão "End Lab" (Encerrar laboratório) nestas instruções e salve as configurações de aterramento.
```
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 do projeto ou pode ter perdido a etapa em que você mudou o ID do repositório de dados do Criador de agentes de livros de receitas antigos. Verifique o ID do repositório de dados no Agent Builder > Repositórios de dados > old-cookbooks.
Teste algumas mensagens de chat. Talvez você possa começar com o que está abaixo. Se quiser, teste outros.
```
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, depois, em Receber código.
Na parte de cima da janela de código, clique em Open 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 adaptá-lo ao que queremos. Antes de começar, execute a primeira célula de código para se conectar ao compute e instalar o SDK da AI Platform. Depois que o bloco for executado, você vai receber uma solicitação para reiniciar a sessão. Vá em frente e crie as chaves.
Vá para o código que extraímos do Vertex AI Studio. Mude o nome do método multiturn_generate_content para start_chat_session.
Role até a chamada do 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 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 como a abaixo.OBSERVAÇÃO: NÃO COPIE este código para o notebook. Ele está aqui apenas como uma verificação de sanidade.

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 nova 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 concluir o bloco automaticamente. 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 o que realmente queremos é o campo text aninhado. Modifique o bloco de código para imprimir apenas essa seção, como:
```
response = chat.send_message("How can I tell if a tomato is ripe?")
print(response.candidates[0].content.parts[0].text)
```
Agora que temos o código do chat funcionando, vamos integrá-lo ao nosso 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.

Localize o comentário:

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

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

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

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

Remova os comentários desta seção de código (até a próxima seção Setup done, let's build the page UI) e a explore. Ele cria ou recupera as variáveis da sessão de chat e do histórico.
Em seguida, precisamos integrar a funcionalidade de histórico e chat à interface. Role o código até encontrar o comentário abaixo.
```
#
# Here's the code to create the chat interface
# Uncomment the below code when instructed
#
```
Remova o comentário do restante do código abaixo dele e confira. Se quiser, destaque-a e peça para o Gemini explicar a funcionalidade dela.
Ótimo, 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 o bot pode saber 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 próprio assistente de culinária com IA :-)

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

Quando conectamos a página "Cooking Advice" à fonte com base, fizemos isso usando 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 diretamente da documentação do Discovery Engine neste link. Você pode encontrar uma cópia em funcionamento 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 percorrer os resultados, e isso é algo que não precisamos para nosso aplicativo básico.
Role até o final do arquivo e descomente toda a seção abaixo de Here are the first 5 recipes I found.
Destaque toda a seção que você acabou de remover os comentários e abra o chat do Gemini Code. Pergunta, Explain the highlighted code. Se você não tiver nada selecionado, o Gemini poderá explicar o arquivo inteiro. Se você destacar uma seção e pedir para o Gemini explicar, comentar ou melhorar, ele vai fazer isso.Leia a explicação. Usar um notebook do Colab Enterprise é uma ótima maneira de conhecer as APIs Gemini antes de integrá-las ao seu aplicativo. Ele é especialmente útil para conhecer algumas das APIs mais recentes, que podem não estar tão bem documentadas.
Na janela do terminal do editor, execute build.sh para implantar o aplicativo final. Aguarde a nova versão ser 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 navegar até Cloud Run e clique em recipe-web-app.
Localize o URL de teste do aplicativo (na parte de cima) e abra-o em uma nova guia do navegador.
A página inicial do aplicativo vai aparecer. Observe o layout básico e a navegação 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 Cooking Advice.
Depois de alguns instantes, a interface de chat vai aparecer. Novamente, observe o layout principal fornecido pelo Streamlit.

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

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. Navegue até a página de pesquisa de receitas e faça algumas pesquisas. Por exemplo:
```
Chili con carne

Chili, corn, rice

Lemon Meringue Pie

A dessert containing strawberries
```

15. Parabéns!

Você criou um app usando os aplicativos do Vertex AI Agent Builder. No 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. Você pode excluir seu projeto do Cloud 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 do Cloud interrompe o faturamento de todos os recursos usados nesse projeto.

Se quiser, exclua o projeto:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

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

Exclua o diretório do projeto do codelab:
```
rm -rf ~/task-app
```
Aviso: Esta próxima ação não pode ser desfeita. Se você quiser excluir tudo no Cloud Shell para liberar espaço, exclua seu diretório principal inteiro. Confira se tudo o que você quer manter está salvo em outro lugar.
```
sudo rm -rf $HOME
```