Criei um Chatbot para me Ajudar a Economizar na Compra de Materiais de Construção

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.4.1</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.gasparbarancelli</groupId>
	<artifactId>menor-preco</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>menor-preco</name>
	<description>Demo project for Spring Boot</description>
	<url/>
	<licenses>
		<license/>
	</licenses>
	<developers>
		<developer/>
	</developers>
	<scm>
		<connection/>
		<developerConnection/>
		<tag/>
		<url/>
	</scm>
	<properties>
		<java.version>23</java.version>
		<spring-ai.version>1.0.0-M4</spring-ai.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.ai</groupId>
			<artifactId>spring-ai-openai-spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.ai</groupId>
				<artifactId>spring-ai-bom</artifactId>
				<version>${spring-ai.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>

</project>

spring.application.name=menor-preco

spring.ai.openai.api-key=${API_KEY}
spring.ai.openai.chat.options.model=gpt-4o
spring.ai.openai.chat.options.functions=functionSearchCategories,functionSearchProducts

package com.gasparbarancelli;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MenorPrecoApplication {

	public static void main(String[] args) {
		SpringApplication.run(MenorPrecoApplication.class, args);
	}

}

package com.gasparbarancelli.transport.http;

import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.openai.OpenAiChatModel;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/")
public class ChatbotApi {

    private final OpenAiChatModel openAiChatClient;
    private List<Message> messages = new ArrayList<>();

    public ChatbotApi(OpenAiChatModel openAiChatClient) {
        this.openAiChatClient = openAiChatClient;
        messages.add(new SystemMessage("""
                Você é um assistente especialista em compras, dedicado a ajudar os usuários a economizar.
                Sua missão é fornecer sugestões detalhadas e precisas sobre os produtos mais econômicos disponíveis.

                Diretrizes para suas respostas:
                1. Sempre priorize listar os produtos com os menores preços e ofereça detalhes relevantes, como:
                   - Nome do produto
                   - Preço
                   - Estabelecimento
                   - Endereço (se disponível)

                2. Responda sempre no formato Markdown, garantindo que suas mensagens sejam claras e visualmente organizadas.

                3. Utilize os seguintes elementos do Markdown:
                   - Títulos para organizar a informação.
                   - Texto em negrito e itálico para destacar informações importantes.
                   - Listas ordenadas ou não ordenadas para apresentar múltiplas opções de forma legível.
                   - Blocos de código, se necessário, para apresentar dados técnicos.
                   - Links para direcionar o usuário a mais informações ou compras online.

                4. Certifique-se de que o Markdown gerado seja bem estruturado e fácil de entender.

                Sua prioridade é ajudar o usuário a economizar de forma eficiente e fornecer respostas que transmitam confiança e profissionalismo.
                """));

    }

    @GetMapping
    public String hello(@RequestParam("message") String message) {
        UserMessage userMessage = new UserMessage(message);
        messages.add(userMessage);

        ChatResponse response = openAiChatClient.call(new Prompt(messages));

        var content = response.getResult().getOutput().getContent();
        messages.add(new AssistantMessage(content));
        return content;
    }

}

package com.gasparbarancelli.interactors;

import com.gasparbarancelli.entities.CategoryResponse;
import com.gasparbarancelli.entities.Location;
import com.gasparbarancelli.entities.ProductResponse;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

import java.util.ArrayList;
import java.util.List;

@Service
public class ProductService {

    private static final String CATEGORY_API_URL = "https://menorpreco.notaparana.pr.gov.br/api/v1/categorias";
    private static final String PRODUCT_API_URL = "https://menorpreco.notaparana.pr.gov.br/api/v1/produtos";
    private static final int BATCH_SIZE = 50;

    private final RestClient restClient;

    public ProductService() {
        this.restClient = RestClient.builder().build();
    }

    public List<CategoryResponse.Category> fetchCategories(String product) {
        try {
            String url = String.format("%s?local=%s&termo=%s&raio=2",
                    CATEGORY_API_URL, Location.PATO_BRANCO.getCode(), product);

            CategoryResponse response = restClient.method(HttpMethod.GET)
                    .uri(url)
                    .header(HttpHeaders.ACCEPT, "application/json")
                    .retrieve()
                    .body(CategoryResponse.class);

            return response.categories();
        } catch (Exception e) {
            throw new RuntimeException("Error fetching categories for product: " + product, e);
        }
    }

    public List<ProductResponse.Product> searchProductsInLocation(String location, String product, String categoryId) {
        List<ProductResponse.Product> allProducts = new ArrayList<>();
        int offset = 0;

        while (true) {
            try {
                String url = String.format("%s?local=%s&termo=%s&categoria=%s&offset=%d&raio=2&data=-1&ordem=0",
                        PRODUCT_API_URL, location, product, categoryId, offset);

                ProductResponse response = restClient.method(HttpMethod.GET)
                        .uri(url)
                        .header(HttpHeaders.ACCEPT, "application/json")
                        .retrieve()
                        .body(ProductResponse.class);

                if (response.products() != null && !response.products().isEmpty()) {
                    allProducts.addAll(response.products());
                }

                if (response.products() == null || response.products().size() < BATCH_SIZE) {
                    break;
                }

                offset += BATCH_SIZE;
            } catch (Exception e) {
                throw new RuntimeException("Error fetching products for category: " + categoryId, e);
            }
        }
        return allProducts;
    }

}

package com.gasparbarancelli.interactors;

import com.fasterxml.jackson.annotation.JsonClassDescription;
import com.gasparbarancelli.entities.CategoryResponse;
import org.springframework.context.annotation.Description;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.function.Function;

@Service
@Description("Antes de conseguirmos as informações dos materiais de construções precisamos identificar a sua categoria")
public class FunctionSearchCategories implements Function<FunctionSearchCategories.Request, FunctionSearchCategories.Response> {

    private final ProductService productService;

    public FunctionSearchCategories(ProductService productService) {
        this.productService = productService;
    }

    @JsonClassDescription("Informações referentes as categorias de um material de construção, como quantidade, nome e seu identificador")
    public record Request(String product) {}
    public record Response(List<CategoryResponse.Category> categories) {}

    @Override
    public Response apply(Request request) {
        var product = request.product();
        return new Response(productService.fetchCategories(product));
    }

}

package com.gasparbarancelli.interactors;

import com.fasterxml.jackson.annotation.JsonClassDescription;
import com.gasparbarancelli.entities.Location;
import com.gasparbarancelli.entities.ProductResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Description;
import org.springframework.stereotype.Service;

import java.util.Comparator;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Stream;

@Service
@Description("Recupera as notas fiscais de produtos comercializados no dia atual, podendo identificar qual foi o preco mais alto ou baixo pago por um produto")
public class FunctionSearchProducts implements Function<FunctionSearchProducts.Request, FunctionSearchProducts.Response> {

    private static final Logger LOGGER = LoggerFactory.getLogger(FunctionSearchProducts.class);

    private final ProductService productService;

    public FunctionSearchProducts(ProductService productService) {
        this.productService = productService;
    }

    @JsonClassDescription("Informações referentes ao material de construção, como descrição, preço e estabelecimento em qual o material foi comercializado")
    public record Request(String product, String categoryId) {}
    public record Response(List<ProductResponse.Product> products) {}

    @Override
    public Response apply(Request request) {
        var product = request.product();
        var categoryId = request.categoryId();

        List<String> locationCodes = Location.getCodes();

        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<List<ProductResponse.Product>>> futures = locationCodes.stream()
                    .map(location -> executor.submit(() -> productService.searchProductsInLocation(location, product, categoryId)))
                    .toList();

            return new Response(futures.stream()
                    .flatMap(future -> {
                        try {
                            return future.get(30, TimeUnit.SECONDS).stream();
                        } catch (Exception e) {
                            LOGGER.info("Erro ou timeout para a localização: " + e.getMessage());
                            return Stream.empty();
                        }
                    })
                    .sorted(Comparator.comparing(ProductResponse.Product::price))
                    .toList());
        }
    }

}

package com.gasparbarancelli.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig {

    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**")
                        .allowedOrigins("http://localhost:4200")
                        .allowedMethods("GET", "OPTIONS")
                        .allowedHeaders("*")
                        .allowCredentials(true);
            }
        };
    }
}

import { Component } from '@angular/core';
import { ChatService } from './chat.service';

export interface ChatMessage {
  message: string;
  send: boolean;
}

@Component({
  selector: 'app-chat',
  standalone: false,
  templateUrl: './chat.component.html',
  styleUrls: ['./chat.component.scss']
})
export class ChatComponent {

  messages: ChatMessage[] = [];
  inputMessage: string = '';

  constructor(private chatService: ChatService) {}

  sendMessage(): void {
    if (this.inputMessage.trim()) {
      const userMessage: ChatMessage = { message: this.inputMessage, send: true };
      this.messages.push(userMessage);

      this.chatService.send(this.inputMessage).subscribe({
        next: response => {
          const botMessage: ChatMessage = { message: response, send: false };
          this.messages.push(botMessage);
        },
        error: error => {
          console.error('Erro ao enviar mensagem:', error);
      }});
      this.inputMessage = '';
    }
  }
}

<div class="chat-container">
  <div class="chat-messages">
    <div *ngFor="let msg of messages"
      [ngClass]="{ 'message-send': msg.send, 'message-receive': !msg.send }"
      class="message">
      <markdown
        [data]="msg.message"
        [disableSanitizer]="true">
      </markdown>
    </div>
  </div>
  <div class="chat-input">
    <input
      type="text"
      [(ngModel)]="inputMessage"
      placeholder="Digite uma mensagem"
      (keydown.enter)="sendMessage()"/>
    <button (click)="sendMessage()">Enviar</button>
  </div>
</div>

.chat-container {
  display: flex;
  flex-direction: column;
  height: 100%;
  border: 1px solid #ccc;
  border-radius: 8px;
  padding: 10px;
}

.chat-messages {
  flex: 1;
  overflow-y: auto;
  margin-bottom: 10px;
  display: flex;
  flex-direction: column;
  gap: 10px;
}

.message {
  padding: 10px;
  border-radius: 8px;
  max-width: 60%;
  word-wrap: break-word;
}

.message-send {
  align-self: flex-end;
  background-color: #007bff;
  color: white;
  text-align: left;
}

.message-receive {
  align-self: flex-start;
  background-color: #f1f0f0;
  color: black;
  text-align: left;
}

.chat-input {
  display: flex;
  gap: 5px;
}

.chat-input input {
  flex: 1;
  padding: 10px;
  border: 1px solid #ccc;
  border-radius: 8px;
}

.chat-input button {
  padding: 10px;
  background-color: #007bff;
  color: white;
  border: none;
  border-radius: 8px;
  cursor: pointer;
}

.chat-input button:hover {
  background-color: #0056b3;
}

import {Injectable} from '@angular/core';
import {HttpClient} from '@angular/common/http';
import {Observable} from 'rxjs';

@Injectable()
export class ChatService {

  constructor(private httpClient: HttpClient) {
  }

  send(message: string): Observable<string> {
    const url = `http://localhost:8080/?message=${message}`;
    return this.httpClient.get(url, {responseType: 'text'});
  }

}

import {NgModule} from '@angular/core';
import {CommonModule} from '@angular/common';
import {ChatComponent} from './chat.component';
import {ChatService} from './chat.service';
import {FormsModule} from '@angular/forms';
import {MarkdownComponent, provideMarkdown} from 'ngx-markdown';

@NgModule({
  declarations: [
    ChatComponent
  ],
  exports: [
    ChatComponent
  ],
  imports: [
    CommonModule,
    FormsModule,
    MarkdownComponent
  ],
  providers: [
    ChatService,
    provideMarkdown()
  ]
})
export class ChatModule {
}

<app-chat></app-chat>

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  standalone: false,
})
export class AppComponent {
}

import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';

import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import {ChatModule} from './chat/chat.module';
import {HttpClientModule} from '@angular/common/http';

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    AppRoutingModule,
    ChatModule,
    HttpClientModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }