Crie um app de recomendação contextual de posições de ioga com o Firestore, a pesquisa vetorial e o Gemini 2.0 (versão Java).

1. Visão geral

No mundo dos apps de bem-estar e fitness, é fundamental oferecer aos usuários uma experiência rica e envolvente. Para um app de ioga, isso significa ir além de simples descrições de texto das posturas e oferecer informações abrangentes, conteúdo multimídia e recursos de pesquisa inteligentes. Neste blog, vamos mostrar como criar um banco de dados robusto de posturas de ioga usando o Firestore do Google Cloud, aproveitar a extensão de pesquisa vetorial para correspondência contextual e integrar o poder do Gemini 2.0 Flash (experimental) para trabalhar com conteúdo multimodal.

Por que o Firestore?

O Firestore, banco de dados de documentos NoSQL sem servidor do Google Cloud, é uma excelente opção para criar aplicativos escalonáveis e dinâmicos. Confira por que ele é perfeito para nosso app de ioga:

Escalonabilidade e performance:o Firestore faz o escalonamento automático para lidar com milhões de usuários e conjuntos de dados massivos, garantindo que seu app permaneça responsivo mesmo com o crescimento.
Atualizações em tempo real: a sincronização em tempo real integrada mantém os dados consistentes em todos os clientes conectados, o que é perfeito para recursos como aulas ao vivo ou prática colaborativa.
Modelo de dados flexível:a estrutura baseada em documentos do Firestore permite armazenar diversos tipos de dados, incluindo texto, imagens e até mesmo embeddings, o que o torna ideal para representar informações complexas sobre posturas de ioga.
Consultas avançadas:o Firestore é compatível com consultas complexas, incluindo igualdade, desigualdade e, agora, com a nova extensão, pesquisas de similaridade de vetores.
Suporte off-line:o Firestore armazena dados em cache localmente, permitindo que o app funcione mesmo quando os usuários estão off-line.

Melhorar a pesquisa com a extensão de pesquisa de vetores do Firestore

A pesquisa tradicional baseada em palavras-chave pode ser limitada ao lidar com conceitos complexos, como posturas de ioga. Um usuário pode pesquisar uma postura que "abre os quadris" ou "melhora o equilíbrio" sem saber o nome específico da postura. É aí que entra a Pesquisa Vetorial.

Com a pesquisa vetorial do Firestore, é possível:

Gerar embeddings:transforme descrições de texto e, no futuro, imagens e áudio em representações de vetores numéricos (embeddings) que capturam o significado semântico usando modelos como os disponíveis na Vertex AI ou modelos personalizados.
Armazenar embeddings:armazene esses embeddings diretamente em documentos do Firestore.
Realizar pesquisas de similaridade:consulte seu banco de dados para encontrar documentos semanticamente semelhantes a um determinado vetor de consulta, permitindo a correspondência contextual.

Integrar o Gemini 2.0 Flash (experimental)

O Gemini 2.0 Flash é o modelo de IA multimodal de ponta do Google. Ainda em fase experimental, ele oferece possibilidades interessantes para enriquecer nosso app Yoga:

Geração de texto: use o Gemini 2.0 Flash para gerar descrições detalhadas de posturas de ioga, incluindo benefícios, modificações e contraindicações.
Geração de imagens (simulada): embora a geração direta de imagens com o Gemini ainda não esteja disponível publicamente, simulei esse recurso usando o Imagen do Google, gerando imagens que representam visualmente as poses.
Geração de áudio (imitado): da mesma forma, podemos usar um serviço de conversão de texto em voz (TTS) para criar instruções de áudio para cada postura, orientando os usuários durante a prática.

Talvez eu proponha a integração para melhorar o app e usar os seguintes recursos do modelo:

API Multimodal Live: essa nova API ajuda você a criar aplicativos de streaming de áudio e visão em tempo real com uso de ferramentas.
Velocidade e desempenho: o Gemini 2.0 Flash tem um tempo até o primeiro token (TTFT, na sigla em inglês) significativamente melhorado em relação ao Gemini 1.5 Flash.
Experiências de agente aprimoradas: o Gemini 2.0 oferece melhorias na compreensão multimodal, programação, acompanhamento de instruções complexas e chamadas de função. Essas melhorias funcionam juntas para oferecer experiências melhores com agentes.

Para mais detalhes, consulte esta página de documentação sobre o Gemini 1.5 Flash.

Embasamento com a Pesquisa Google

Para aumentar a credibilidade e fornecer mais recursos, podemos integrar a Pesquisa Google para fundamentar as informações fornecidas pelo nosso app. Isso significa que:

Pesquisa contextual:quando um usuário administrador insere os detalhes de uma postura, podemos usar o nome dela para fazer uma Pesquisa Google.
Extração de URL:dos resultados da pesquisa, podemos extrair URLs relevantes, como artigos, vídeos ou sites de ioga confiáveis, e mostrá-los no app.

O que você vai criar

Neste laboratório, você vai:

Criar uma coleção do Firestore e carregar documentos do Yoga
Saiba como criar aplicativos CRUD com o Firestore
Gerar descrição de postura de ioga com o Gemini 2.0 Flash
Ativar a pesquisa vetorial do Firebase com a integração do Firestore
Gerar embeddings com base na descrição de uma aula de yoga
Realizar pesquisa de similaridade para o texto de pesquisa do usuário

Requisitos

Use um navegador, como o Chrome ou o Firefox.
Ter um projeto do Google Cloud com o faturamento ativado.

2. Antes de começar

Criar um projeto

No console do Google Cloud, na página de seletor de projetos, selecione ou crie um projeto do Google Cloud.
Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto .
Você vai usar o Cloud Shell, um ambiente de linha de comando executado no Google Cloud que vem pré-carregado com bq. Clique em "Ativar o Cloud Shell" na parte de cima do console do Google Cloud.

Depois de se conectar ao Cloud Shell, verifique se sua conta já está autenticada e se o projeto está configurado com o ID do seu projeto usando o seguinte comando:

gcloud auth list

Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.

gcloud config list project

Se o projeto não estiver definido, use este comando:

gcloud config set project <YOUR_PROJECT_ID>

Siga este link para ativar as APIs necessárias até que seja possível clicar no botão "Ativar".

Se alguma API for esquecida, você sempre poderá ativá-la durante a implementação.

Consulte a documentação para ver o uso e os comandos gcloud.

3. Configuração do banco de dados

A documentação tem etapas mais completas sobre como configurar uma instância do Firestore. Em geral, para começar, vou seguir estas etapas:

1 Acesse o Visualizador do Firestore e, na tela "Selecionar um serviço de banco de dados", escolha "Firestore no modo nativo".

Selecione um local para o Firestore. Escolha us-central1 e siga essa opção sempre que escolher região / local neste codelab.
Clique em "Criar banco de dados". Se for a primeira vez, deixe como banco de dados "(padrão)".

Ao criar um projeto do Firestore, a API no Cloud API Manager também é ativada.

IMPORTANTE: escolha a versão de TESTE (não de PRODUÇÃO) das regras de segurança para que os dados fiquem acessíveis.
Depois de configurado, você vai ver a visualização do banco de dados, da coleção e do documento do Firestore no modo nativo, como mostrado na imagem abaixo:

Não faça isso ainda, mas, para registrar, você pode clicar em "Iniciar coleta" e criar uma nova coleção. Defina o ID da coleção como "poses". Clique no botão Salvar.

Dicas profissionais para aplicativos de produção:

Depois de finalizar o modelo de dados e identificar quem pode acessar diferentes tipos de documentos, crie, edite e monitore as regras de segurança na interface do Firebase. Acesse as regras de segurança neste link: https://console.firebase.google.com/u/0/project/<<your_project_id>>/firestore/rules
Edite, monitore e teste suas regras de segurança antes de implantar / lançar o projeto da fase de desenvolvimento, porque elas costumam ser as culpadas silenciosas por um app funcionar de maneira diferente :)

Para esta demonstração, vamos usá-lo no modo TEST.

4. API REST do Firestore

A API REST pode ser útil nos seguintes casos de uso: Ao acessar o Firestore a partir de um ambiente com recursos restritos em que não é possível executar uma biblioteca de cliente completa. Ao automatizar a administração ou recuperar metadados detalhados do banco de dados.
A maneira mais fácil de usar o Firestore é usar uma das bibliotecas de cliente nativas, mas há algumas situações em que é melhor chamar a API REST diretamente.
Neste blog, você vai conferir o uso e a demonstração das APIs REST do Firestore, e não das bibliotecas de cliente nativas.
Para fazer a autenticação, a API REST do Firestore aceita um token de ID do Firebase Authentication ou um token do Google Identity OAuth 2.0. Para mais informações sobre autenticação e autorização, consulte a documentação.
Todos os endpoints da API REST estão no URL base https://firestore.googleapis.com/v1/.

Spring Boot e API Firestore

Esta solução no framework Spring Boot demonstra um aplicativo cliente que usa APIs do Firestore para coletar e modificar detalhes de posturas de ioga e respiração com uma experiência interativa para o usuário.

Para uma explicação detalhada da solução CRUD do Firestore no app de posturas de ioga, acesse o link do blog.

Para se concentrar na solução atual e aprender a parte do CRUD em tempo real, clone toda a solução focada neste blog do repositório abaixo no terminal do Cloud Shell e receba uma cópia da base de código.

git clone https://github.com/AbiramiSukumaran/firestore-poserecommender

Observação:

Depois de clonar esse repositório, basta fazer algumas mudanças no ID do projeto, nas APIs etc. Nenhuma outra mudança é necessária para colocar o aplicativo em funcionamento. Cada componente do aplicativo é explicado nas próximas seções. Confira uma lista de mudanças:
No arquivo src/main/java/com/example/demo/GenerateImageSample.java, substitua "<<YOUR_PROJECT_ID>>" pelo ID do projeto.
No arquivo src/main/java/com/example/demo/GenerateEmbeddings.java, substitua "<<YOUR_PROJECT_ID>>" pelo ID do projeto.
Em src/main/java/com/example/demo/PoseController.java, substitua todas as instâncias de "<<YOUR_PROJECT_ID>>" e o nome do banco de dados,, neste caso "(default)",, por valores adequados da sua configuração:
Em src/main/java/com/example/demo/PoseController.java, substitua "[YOUR_API_KEY]" pela sua chave de API do Gemini 2.0 Flash. Você pode encontrar isso no AI Studio.
Se você quiser testar localmente, execute os seguintes comandos na pasta do projeto no terminal do Cloud Shell:

mvn package

mvn spring-boot:run

No momento, é possível ver o aplicativo em execução clicando na opção "Visualização da Web" no terminal do Cloud Shell. Ainda não estamos prontos para realizar testes e usar o aplicativo.

Opcional:se você quiser implantar o app no Cloud Run, será necessário inicializar um novo aplicativo Java do Cloud Run do zero no Editor do Cloud Shell e adicionar os arquivos src e de modelo do repositório ao novo projeto nas pastas respectivas. Isso porque o projeto atual do repositório do GitHub não está configurado por padrão para a configuração de implantação do Cloud Run. Nesse caso, siga estas etapas em vez de clonar o repositório atual:
Acesse o editor do Cloud Shell (verifique se o editor está aberto e não o terminal) e clique no ícone do nome do projeto do Google Cloud no lado esquerdo da barra de status (a parte bloqueada na captura de tela abaixo).

Selecione "Novo aplicativo" -> "Aplicativo do Cloud Run" -> "Java: Cloud Run" na lista de opções e nomeie como "firestore-poserecommender".

Agora você vai ver um modelo de pilha completa para o aplicativo Java do Cloud Run, pré-configurado e pronto para uso.
Remova a classe Controller atual e copie os seguintes arquivos para as respectivas pastas na estrutura do projeto:

firestore-poserecommender/src/main/java/com/example/demo/

FirestoreSampleApplication.java
GenerateEmbeddings.java
GenerateImageSample.java
Pose.java
PoseController.java

ServletInitializer.java

         firestore-poserecommender/src/main/resources/static/

Index.html

firestore-poserecommender/src/main/resources/templates/

contextsearch.html
createpose.html
errmessage.html
pose.html
ryoq.html
searchpose.html
showmessage.html

firestore-poserecommender/

Dockerfile
Faça as mudanças nos arquivos correspondentes para substituir o ID do projeto e a chave de API pelos seus respectivos valores. (etapas 1a,1b, 1c e 1d acima).

5. Ingestão de dados

Os dados do aplicativo estão disponíveis neste arquivo data.json: https://github.com/AbiramiSukumaran/firestore-poserecommender/blob/main/data.json

Se você quiser começar com alguns dados predefinidos, copie o JSON e substitua todas as ocorrências de "<<YOUR_PROJECT_ID>>" pelo seu valor.

Acesse o Firestore Studio.
Verifique se você criou uma coleção chamada "poses".
Adicione manualmente um documento por vez do arquivo do repositório mencionado acima.

Como alternativa, você pode importar dados de uma só vez do conjunto predefinido que criamos para você seguindo estas etapas:

Acesse o terminal do Cloud Shell e verifique se o projeto na nuvem ativo do Google Cloud está definido e se você tem autorização. Crie um bucket no seu projeto com o comando gsutil abaixo. Substitua a variável <PROJECT_ID> no comando abaixo pelo ID do projeto do Google Cloud:

gsutil mb -l us gs://<PROJECT_ID>-yoga-poses-bucket

Agora que o bucket foi criado, precisamos copiar a exportação do banco de dados que preparamos para ele antes de importar para o banco de dados do Firebase. Use o comando abaixo:

gsutil cp -r gs://demo-bq-gemini-public/yoga_poses gs://<PROJECT_ID>-yoga-poses-bucket

Agora que temos os dados para importar, podemos passar para a etapa final de importação para o banco de dados do Firebase (padrão) que criamos.

Acesse o console do Firestore agora e clique em Importar/Exportar no menu de navegação à esquerda.

Selecione "Importar" e escolha o caminho do Cloud Storage que você acabou de criar. Navegue até poder selecionar o arquivo "yoga_poses.overall_export_metadata":

Clique em Importar.

A importação leva alguns segundos. Quando estiver pronta, você poderá validar o banco de dados e a coleção do Firestore acessando https://console.cloud.google.com/firestore/databases, selecionando o banco de dados default e a coleção poses, conforme mostrado abaixo:

Outro método é criar os registros manualmente pelo aplicativo depois de fazer a implantação usando a ação "Criar uma nova pose".

6. Vector Search

Ativar a extensão de pesquisa de vetor do Firestore

Use esta extensão para incorporar e consultar automaticamente seus documentos do Firestore com o novo recurso de pesquisa de vetores. Isso vai levar você ao Firebase Extensions Hub.

Ao instalar a extensão Pesquisa vetorial, você especifica uma coleção e um nome de campo de documento. Adicionar ou atualizar um documento com esse campo aciona a extensão para calcular um embedding de vetor para o documento. Esse embedding de vetor é gravado no mesmo documento, que é indexado no repositório vetorial e fica pronto para ser consultado.

Vamos analisar as etapas:

Instale a extensão:

Instale a extensão "Pesquisa de vetores com o Firestore" no Marketplace de extensões do Firebase clicando em "Instalar no console do Firebase".

IMPORTANTE:

Ao acessar essa página de extensões pela primeira vez, selecione o mesmo projeto em que você está trabalhando no console do Google Cloud listado no console do Firebase.

Se o projeto não estiver listado, adicione-o no Firebase (escolha seu projeto do Google Cloud na lista).

Configurar a extensão:

Especifique a coleção ("poses"), o campo que contém o texto a ser incorporado ("posture") e outros parâmetros, como as dimensões de incorporação.

Se houver APIs que precisam ser ativadas listadas nesta etapa, a página de configuração permitirá que você faça isso. Siga as etapas de acordo com a necessidade.

Se a página não responder depois de um tempo, atualize-a para ver as APIs ativadas.

Em uma das etapas a seguir, você poderá usar o LLM de sua escolha para gerar os embeddings. Escolha "Vertex AI".

As próximas configurações estão relacionadas à sua coleção e ao campo que você quer incorporar:

LLM: Vertex AI

Caminho da coleção: poses

Limite de consulta padrão: 3

Medida de distância: cosseno

Nome do campo de entrada: postura

Nome do campo de saída: embedding

Nome do campo de status: status

Incorporar documentos atuais: sim

Atualizar embeddings atuais: sim

Local do Cloud Functions: us-central1

Ativar eventos: não marcada

Depois de configurar tudo isso, clique no botão "Instalar extensão". Isso leva de 3 a 5 minutos.

Gerar embeddings:

À medida que você adiciona ou atualiza documentos na coleção "poses", a extensão gera incorporações automaticamente usando um modelo pré-treinado ou um modelo de sua escolha por um endpoint de API. Neste caso, escolhemos a Vertex AI na configuração da extensão.

Criação de índice

Isso vai exigir a criação de um índice no campo de incorporação no momento do uso da incorporação no aplicativo.

O Firestore cria índices automaticamente para consultas básicas. No entanto, você pode deixar o Firestore gerar a sintaxe de índice executando consultas que não têm um índice. Ele vai fornecer um link para o índice gerado na mensagem de erro no lado do aplicativo. Confira a lista de etapas para criar um índice vetorial:

Acessar o terminal do Cloud Shell
Execute este comando:

gcloud firestore indexes composite create --collection-group="poses" --query-scope=COLLECTION --database="(default)" --field-config vector-config='{"dimension":"768", "flat": "{}"}',field-path="embedding"

Saiba mais neste link.

Depois que um índice vetorial é criado, é possível realizar uma pesquisa de vizinho mais próximo com seus embeddings de vetor.

Observação importante:

A partir desse momento, você não precisa fazer nenhuma mudança na fonte. Basta acompanhar para entender o que o aplicativo está fazendo.

Como realizar uma pesquisa vetorial

Vamos conferir como o aplicativo recém-criado aborda a Pesquisa Vetorial. Depois que os embeddings são armazenados, é possível usar a classe VectorQuery do SDK do Java do Firestore para realizar a pesquisa de vetor e receber os resultados do vizinho mais próximo:

CollectionReference coll = firestore.collection("poses");
    VectorQuery vectorQuery = coll.findNearest(
        "embedding",
        userSearchTextEmbedding, 
        /* limit */ 3,
        VectorQuery.DistanceMeasure.EUCLIDEAN,
        VectorQueryOptions.newBuilder().setDistanceResultField("vector_distance")
         .setDistanceThreshold(2.0)
          .build());
ApiFuture<VectorQuerySnapshot> future = vectorQuery.get();
VectorQuerySnapshot vectorQuerySnapshot = future.get();
List<Pose> posesList = new ArrayList<Pose>();
// Get the ID of the closest document (assuming results are sorted by distance)
String closestDocumentId = vectorQuerySnapshot.getDocuments().get(0).getId();

Este snippet compara o embedding do texto de pesquisa do usuário com os embeddings dos documentos no Firestore e extrai o mais próximo contextual.

7. Gemini 2.0 Flash

Integração do Gemini 2.0 Flash (para geração de descrição)

Vamos conferir como o aplicativo recém-criado lida com a integração do Gemini 2.0 Flash para geração de descrições.

Agora, digamos que um usuário administrador / instrutor de ioga queira inserir os detalhes das posturas com a ajuda do Gemini 2.0 Flash e fazer uma pesquisa para ver as correspondências mais próximas. Isso resulta na extração dos detalhes das posturas correspondentes, além de objetos multimodais que oferecem suporte aos resultados.

String apiUrl = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp:generateContent?key=[YOUR_API_KEY]";
Map<String, Object> requestBody = new HashMap<>();
List<Map<String, Object>> contents = new ArrayList<>();
List<Map<String, Object>> tools = new ArrayList<>();
Map<String, Object> content = new HashMap<>();
List<Map<String, Object>> parts = new ArrayList<>();
Map<String, Object> part = new HashMap<>();
part.put("text", prompt);
parts.add(part);
content.put("parts", parts);
contents.add(content);
requestBody.put("contents", contents);
/**Setting up Grounding*/
Map<String, Object> googleSearchTool = new HashMap<>();
googleSearchTool.put("googleSearch", new HashMap<>());
tools.add(googleSearchTool);
requestBody.put("tools", tools);

HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(requestBody, headers);
ResponseEntity<String> response = restTemplate.exchange(apiUrl, HttpMethod.POST, requestEntity, String.class);
System.out.println("Generated response: " + response);
String responseBody = response.getBody();
JSONObject jsonObject = new JSONObject(responseBody);
JSONArray candidates = jsonObject.getJSONArray("candidates");
JSONObject candidate = candidates.getJSONObject(0);
JSONObject contentResponse = candidate.getJSONObject("content");
JSONArray partsResponse = contentResponse.getJSONArray("parts");
JSONObject partResponse = partsResponse.getJSONObject(0);
String generatedText = partResponse.getString("text");
System.out.println("Generated Text: " + generatedText);

a. Imitação de geração de imagens e áudio

O Gemini 2.0 Flash Experimental é capaz de gerar resultados multimodais, mas ainda não me inscrevi para o acesso antecipado. Por isso, simulei a saída de imagem e áudio com as APIs Imagen e TTS, respectivamente. Imagine como é incrível ter tudo isso gerado com uma chamada de API para o Gemini 2.0 Flash.

try (PredictionServiceClient predictionServiceClient =
          PredictionServiceClient.create(predictionServiceSettings)) {
  
        final EndpointName endpointName =
            EndpointName.ofProjectLocationPublisherModelName(
                projectId, location, "google", "imagen-3.0-generate-001");
  
        Map<String, Object> instancesMap = new HashMap<>();
        instancesMap.put("prompt", prompt);
        Value instances = mapToValue(instancesMap);
  
        Map<String, Object> paramsMap = new HashMap<>();
        paramsMap.put("sampleCount", 1);
        paramsMap.put("aspectRatio", "1:1");
        paramsMap.put("safetyFilterLevel", "block_few");
        paramsMap.put("personGeneration", "allow_adult");
        Value parameters = mapToValue(paramsMap);
  
        PredictResponse predictResponse =
            predictionServiceClient.predict(
                endpointName, Collections.singletonList(instances), parameters);
  
        for (Value prediction : predictResponse.getPredictionsList()) {
          Map<String, Value> fieldsMap = prediction.getStructValue().getFieldsMap();
          if (fieldsMap.containsKey("bytesBase64Encoded")) {
            bytesBase64Encoded = fieldsMap.get("bytesBase64Encoded").getStringValue();
       }
      }
      return bytesBase64Encoded;
    }

 try {
            // Create a Text-to-Speech client
            try (TextToSpeechClient textToSpeechClient = TextToSpeechClient.create()) {
                // Set the text input to be synthesized
                SynthesisInput input = SynthesisInput.newBuilder().setText(postureString).build();

                // Build the voice request, select the language code ("en-US") and the ssml
                // voice gender
                // ("neutral")
                VoiceSelectionParams voice =
                        VoiceSelectionParams.newBuilder()
                                .setLanguageCode("en-US")
                                .setSsmlGender(SsmlVoiceGender.NEUTRAL)
                                .build();

                // Select the type of audio file you want returned
                AudioConfig audioConfig =
                        AudioConfig.newBuilder().setAudioEncoding(AudioEncoding.MP3).build();

                // Perform the text-to-speech request on the text input with the selected voice
                // parameters and audio file type
                SynthesizeSpeechResponse response =
                        textToSpeechClient.synthesizeSpeech(input, voice, audioConfig);

                // Get the audio contents from the response
                ByteString audioContents = response.getAudioContent();

                // Convert to Base64 string
                String base64Audio = Base64.getEncoder().encodeToString(audioContents.toByteArray());

                // Add the Base64 encoded audio to the Pose object
               return base64Audio;
            }

        } catch (Exception e) {
            e.printStackTrace(); // Handle exceptions appropriately. For a real app, log and provide user feedback.
            return "Error in Audio Generation";
        }
}

b. Embasamento com a Pesquisa Google:

Se você verificar o código de invocação do Gemini na etapa 6, vai notar o seguinte snippet de código para ativar o embasamento da Pesquisa Google na resposta do LLM:

 /**Setting up Grounding*/
Map<String, Object> googleSearchTool = new HashMap<>();
googleSearchTool.put("googleSearch", new HashMap<>());
tools.add(googleSearchTool);
requestBody.put("tools", tools);

Isso garante que:

Basear nosso modelo em resultados de pesquisa reais
Extrair URLs relevantes referenciados na pesquisa

8. Execute o aplicativo

Vamos conferir todos os recursos do seu novo aplicativo Java Spring Boot com uma interface da Web Thymeleaf simples:

Operações CRUD do Firestore (criar, ler, atualizar, excluir)
Pesquisa por palavra-chave
Criação de contexto com base em IA generativa
Pesquisa contextual (Pesquisa Vetorial)
Saída multimodal relacionada à pesquisa
Executar sua própria consulta (consultas no formato structuredQuery)

Exemplo: {"structuredQuery":{"select":{"fields":[{"fieldPath":"name"}]},"from":[{"collectionId":"fitness_poses"}]}}

Todos esses recursos discutidos até agora fazem parte do aplicativo que você acabou de criar no repositório: https://github.com/AbiramiSukumaran/firestore-poserecommender

Para criar, executar e implantar, execute os seguintes comandos no terminal do Cloud Shell:

mvn package

mvn spring-boot:run

Você vai ver o resultado e poderá testar os recursos dos aplicativos. Confira o vídeo abaixo para ver a demonstração da saída:

Etapa opcional:

Para implantar no Cloud Run (supondo que você tenha inicializado um novo aplicativo com Dockerfile e copiado os arquivos conforme necessário), execute o seguinte comando no terminal do Cloud Shell no diretório do projeto:

gcloud run deploy --source .

Forneça o nome do aplicativo, o código da região (escolha o de us-central1) e selecione a invocação não autenticada "Y" conforme solicitado. Você vai receber o endpoint do aplicativo no terminal quando a implantação for concluída.

9. Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nesta postagem, siga estas etapas:

No console do Google Cloud, acesse a página Gerenciar recursos.
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

10. Parabéns

Parabéns! Você usou o Firestore para criar um aplicativo robusto e inteligente de gerenciamento de posturas de ioga. Ao combinar o poder do Firestore, da extensão Vector Search e dos recursos do Gemini 2.0 Flash (com geração simulada de imagens e áudio), criamos um app de ioga realmente envolvente e informativo para implementar as operações CRUD, realizar pesquisas contextuais e por palavras-chave e gerar conteúdo multimídia.

Essa abordagem não se limita a apps de ioga. À medida que os modelos de IA, como o Gemini, continuam evoluindo, as possibilidades de criar experiências de usuário ainda mais imersivas e personalizadas só aumentam. Não se esqueça de ficar por dentro dos desenvolvimentos e da documentação mais recentes do Google Cloud e do Firebase para aproveitar todo o potencial dessas tecnologias.

Se eu fosse estender esse app, tentaria fazer duas coisas com o Gemini 2.0 Flash:

Use a API Multimodal Live criando streaming de áudio e visão em tempo real para o caso de uso.
Ative o Modo de raciocínio para gerar os pensamentos por trás das respostas e interagir com dados em tempo real, tornando a experiência mais realista.

Teste e envie uma solicitação de pull :>D!!!