Aplicações Java inteligentes usando Spring AI e Gemini

Neste tutorial, desenvolveremos um aplicativo cliente de bate-papo simples usando o Spring AI integrado ao Google Gemini, um poderoso modelo de linguagem do Google. Para desenvolvedores Java familiarizados com o framework Spring, usar o Spring AI facilita a criação de aplicativos inteligentes sem a necessidade de dependência de fornecedor.

Criaremos uma aplicação semelhante àquela apresentada no tutorial anterior:

Introdução a aplicações Java inteligentes usando Spring AI e OpenAI

Crie um novo projeto Spring Boot.

Crie um novo projeto Spring Boot usando o Spring Initializr (https://start.spring.io/) ou sua IDE.

Seleções:

Projeto: Maven
Idioma: Java
Spring Boot: 3.4.1 (selecione a versão mais recente)
Insira os metadados do seu projeto (nome do pacote, nome do artefato) conforme desejado.
Java: 23 (ou a versão mais recente disponível)

Dependências:

Spring WebPara criar endpoints REST.
Vertex AI GeminiPara integração com os modelos de linguagem do Google.

Verifique o arquivo pom.xml

Certifique-se de que seu pom.xmlprojeto inclua as dependências necessárias para a integração com o Google Gemini:

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-vertex-ai-gemini-spring-boot-starter</artifactId>
  </dependency>
</dependencies>

A dependência spring-ai-vertex-ai-gemini-spring-boot-starterfornece os componentes necessários e a autoconfiguração para usar a API do Gemini em uma aplicação Spring Boot, semelhante ao que spring-ai-openai-spring-boot-starteré fornecido para o OpenAI.

Configurando o projeto

Ao usar a IA do Google em um projeto Spring AI, precisamos configurar duas propriedades no application.propertiesarquivo (ou YAML):

spring.ai.vertex.ai.gemini.projectId=${GEMINI_PROJECT_ID}
spring.ai.vertex.ai.gemini.location=us-east4

Embora o ID do projeto possa ser compartilhado, é uma boa prática também passar esse valor como uma variável de ambiente caso você esteja usando projetos diferentes para ambientes diferentes (DEV, QA, PROD).

Então, como obtemos essa informação?

Primeiro, você precisa criar uma conta do Google Cloud. Se ainda não tiver uma, você pode obter US$ 300 em créditos gratuitamente para começar: https://cloud.google.com/gcp

Em seguida, acesse o console e crie um novo projeto, caso ainda não tenha um no Console do Google Cloud :

Após a criação do projeto, você precisará:

Ative a cobrança para o projeto.
Habilite a API Vertex para o projeto clicando em Enable all Recommended APIs:

Em seguida, precisaremos instalar a ferramenta de linha de comando gcloud.

Instalando a CLI do Google Cloud

Siga o passo a passo listado na documentação para instalar gcloudlocalmente: https://cloud.google.com/sdk/docs/install-sdk.

Após a instalação, inicialize a CLI:

./google-cloud-sdk/bin/gcloud init

Faça login e selecione o projeto que você criou para usar com o Gemini:

Pick cloud project to use:
 [1] [my-project-1]
 [2] [my-project-2]
 ...
 Please enter your numeric choice:

Se você tiver apenas um projeto, gcloud initele será selecionado automaticamente.

Anote o ID do seu projeto para usar no arquivo de propriedades e selecione também a região mais próxima de você. Você pode encontrar todos os locais disponíveis aqui: https://cloud.google.com/gemini/docs/locations.

Com a configuração concluída, estamos prontos para começar a programar.

Criando a classe SimpleChatService

Para começar, vamos criar um SimpleChatServiceobjeto que contenha o ChatClientmodelo e um método que podemos invocar a partir do controlador:

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;

@Service
public class SimpleChatService {

    private final ChatClient chatClient;

    public SimpleChatService(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    public String chat(String message) {
        return this.chatClient.prompt()
                .user(message)
                .call()
                .content();
    }
}

Onde:

Oferece ChatClientuma API para comunicação com um modelo de IA. Suporta modelos de programação síncrona e de fluxo contínuo.
O objeto ChatClienté criado ChatClient.Builder. Você pode obter uma ChatClient.Builderinstância autoconfigurada para qualquer ChatModel do Spring Boot ou criar uma programaticamente.
O método chat methodrecebe uma solicitação message. Usaremos o Promptobjeto da solicitação ChatCliente definiremos a entrada do usuário, passando a mensagem recebida. O call()método envia uma solicitação ao modelo de IA e o content()método retorna a resposta do modelo de IA como uma string.

Observe que o código é exatamente o mesmo do tutorial anterior. Novamente, usar o Spring AI facilita a criação de aplicativos inteligentes sem a dependência de um único fornecedor.

Criando o GoogleGeminiChatController

Crie um controlador e adicione o seguinte código a ele:

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/google-gemini")
public class GoogleGeminiChatController {

    private final SimpleChatService simpleChatService;

    public GoogleGeminiChatController(SimpleChatService simpleChatService) {
        this.simpleChatService = simpleChatService;
    }

    @PostMapping("/chat")
    public ChatResponse chat(@RequestBody String message) {
        return new ChatResponse(this.simpleChatService.chat(message));
    }
}

Este controlador processa as requisições POST para o /api/google-gemini/chatendpoint, extraindo a mensagem do corpo da requisição.

Isso ChatResponseé um recordsinal para que possamos formatar a saída:

public record ChatResponse(String message) {}

6: Testando via requisição HTTP

Se você estiver usando o IntelliJ IDEA Ultimate , pode criar um arquivo api.httpcom o seguinte conteúdo (isso é muito conveniente para testes de requisições HTTP):

POST http://localhost:8080/api/google-gemini/chat
Content-Type: application/json

{
    "message": "Tell me a joke"
}

Alternativamente, você também pode usar o Postman ou ferramentas similares para simular a requisição HTTP.

Se enviarmos a solicitação, poderemos obter uma saída semelhante à seguinte:

{
  "message": "Why don't scientists trust atoms? \n\nBecause they make up everything! \n \nLet me know if you'd like to hear another one! 😄  \n"
}

Resumo

Você criou com sucesso um aplicativo Java básico usando Spring AI e Google Gemini. Explore mais consultando [link para o guia/plataforma].

A documentação oficial do Spring AI: https://docs.spring.io/spring-ai/reference/api/chat/google-vertexai.html
E a documentação da API Google Gemini: https://ai.google/

Boa programação!

De 0 a 10, o quanto você recomendaria este artigo para um amigo?

Powered by: