DEV Community: Lucas Oliveira

💡 Spring Boot + Docker Compose: Uma combinação sensacional!

Lucas Oliveira — Tue, 11 Feb 2025 01:06:14 +0000

Durante meus estudos, topei com uma biblioteca que, apesar de não ser tão nova, eu ainda não conhecia: spring-boot-docker-compose. Achei sensacional e, para compartilhar essa descoberta (e reforçar o aprendizado, claro), resolvi escrever este artigo.

🚀 Começando com Spring Boot e Docker Compose

Antes de tudo, certifique-se de estar na versão 3.x do Spring Boot e de ter o Docker instalado na máquina.

📦 Dependências necessárias

Para o projeto, criaremos um endpoint REST integrado com um banco PostgreSQL. No pom.xml, inclua as seguintes dependências:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-docker-compose</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

Aqui, a estrela do show é a dependência spring-boot-docker-compose, que permite integrar e subir containers do Docker Compose automaticamente!

🛠️ Configurando o Docker Compose
Agora, precisamos definir o banco de dados no arquivo compose.yml:

services:
  db:
    image: postgres:12.22
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: ingredientesdb

Caso você queira personalizar o nome do arquivo, basta configurar oo application.yml:

spring:
  docker:
    compose:
      enabled: true
      file: docker-compose.yml

✨ Pronto! Agora, ao rodar a aplicação, o PostgreSQL será iniciado automaticamente. Você pode conferir os logs ou rodar um docker ps para verificar se o container está rodando:

03:00  INFO 25164 --- [ingredientes-service] o.s.boot.docker.compose.core.DockerCli   :  Container ingredientes-db-1  Started

CONTAINER ID   IMAGE            STATUS        PORTS                    NAMES
4b9b463b0daf   postgres:12.22   Up 3 seconds  0.0.0.0:5432->5432/tcp   ingredientes-db-1

🔍 Bônus: Usando @Profile
Podemos usar essa funcionalidade com @Profile, ativando o Compose apenas em determinados ambientes!

O código completo está disponível no meu GitHub:
🔗 https://github.com/LuLiveira

Se curtiu essa dica ou já usou essa biblioteca, comenta aí! 👇🚀

Entendendo o Algoritmo Breadth-first search (BFS)

Lucas Oliveira — Tue, 04 Feb 2025 00:25:38 +0000

No mundo dos algoritmos, o BFS (Breadth-First Search ou Busca em Largura) é uma técnica fundamental quando queremos explorar caminhos em um grafo de maneira eficiente. Essa abordagem permite encontrar o menor caminho entre dois pontos, e "menor caminho" pode significar diversas coisas:

O menor número de movimentos para atingir um resultado específico;
O menor número de passos para ir de um ponto A até um ponto B;
A provável próxima letra em uma sequência de palavras, entre outros.

O que é um Grafo?

Ao estudar o BFS, nos deparamos com uma estrutura de dados essencial: o grafo. Ele é composto por vértices (ou nós), que representam os elementos do problema, e arestas, que indicam as conexões entre esses elementos.

Por exemplo, imagine que temos um ponto A conectado a um ponto B:

Nesse caso, dizemos que A e B são vizinhos, pois estão conectados diretamente por uma aresta.

A Diferença entre BFS e Busca Binária

Se você já estudou algoritmos, provavelmente conhece a Busca Binária, muito utilizada para encontrar elementos em listas ordenadas, utilizando a estratégia de dividir para conquistar. No entanto, a BFS tem um propósito diferente:

Ela responde à pergunta: "Consigo sair do ponto A e chegar ao ponto B? Se sim, qual o menor número de passos necessários?"

Agora, vamos visualizar melhor esse conceito com um exemplo:

No primeiro exemplo, temos um caminho direto entre A e B. Mas, conforme o grafo se torna mais complexo, encontrar o menor caminho se torna um desafio maior.

Implementando o BFS em Java

Agora, vamos construir um exemplo prático de BFS em Java.

Representação do Grafo

Podemos representar um grafo de várias formas. Aqui, utilizaremos um HashMap, onde cada chave representa um nó e os valores associados são as listas de seus vizinhos:

var graph = new HashMap<String, List<String>>();
graph.put("Voce", List.of("Alice", "Bob", "Claire"));
graph.put("Bob", List.of("Anuj", "Peggy"));
graph.put("Alice", List.of("Peggy"));
graph.put("Claire", List.of("Thom", "Jonny"));
graph.put("Anuj", List.of());
graph.put("Peggy", List.of());
graph.put("Thom", List.of());
graph.put("Jonny", List.of());

Agora que temos nosso grafo, vamos implementar a busca.

Implementação do Algoritmo

Criamos uma fila para armazenar os nós a serem visitados. Como BFS segue a lógica FIFO (First In, First Out), essa estrutura é essencial para garantir que os nós sejam processados na ordem correta.

private static void example(Map<String, List<String>> graph) {
    var filaDeBusca = new ArrayList<>(graph.get("Voce"));
    var verificados = new HashSet<String>();

    while (!filaDeBusca.isEmpty()) {
        String first = filaDeBusca.remove(0);

        // Se o nó já foi verificado, pulamos para o próximo
        if (verificados.contains(first)) {
            continue;
        }

        // Lógica de verificação do elemento desejado
        if (first.startsWith("Jon")) {
            System.out.println("Encontrado: " + first);
            break;
        }

        verificados.add(first);
        filaDeBusca.addAll(Optional.ofNullable(graph.get(first)).orElseGet(List::of));
    }
}

Explicação do Código

Criamos uma fila de busca contendo os vizinhos diretos do nó inicial.
Criamos um conjunto de verificados para evitar visitar o mesmo nó mais de uma vez.
Enquanto a fila não estiver vazia, retiramos o primeiro elemento e verificamos se ele atende ao critério desejado.
Se for o nó procurado, encerramos a busca.
Caso contrário, adicionamos seus vizinhos à fila e marcamos o nó como verificado.

Melhorias e Considerações

A lógica de verificação pode ser personalizada para diferentes problemas.
O uso de Set para armazenar os nós visitados evita laços infinitos e repetições desnecessárias.
Se fosse necessário armazenar o caminho percorrido, poderíamos modificar a estrutura para incluir essa informação.

Conclusão

O algoritmo BFS é uma ferramenta poderosa para encontrar caminhos mínimos em grafos. Ele tem diversas aplicações, como em redes sociais, roteamento de mapas e até mesmo na IA de jogos.

Espero que esse artigo tenha ajudado a compreender melhor o BFS! Caso tenha dúvidas ou sugestões, deixe seu comentário.

Código Fonte: LuLiveira

Explorando a Biblioteca JLama com Spring Boot e LangChain

Lucas Oliveira — Mon, 27 Jan 2025 19:00:20 +0000

Atualmente, muito se fala sobre LLM (Large Language Models). Esses modelos trazem facilidades para diversas áreas, incluindo a programação. LLMs conseguem compreender e gerar mensagens de texto (e outros tipos de dados), permitindo sugestões, correções e até geração de código a partir de prompts textuais.

Neste artigo, vamos explorar a biblioteca JLama, que tem como objetivo integrar modelos LLM ao ecossistema Java. Totalmente desenvolvida em Java, essa biblioteca oferece diferentes formas de uso, seja como uma CLI ou integrada diretamente ao seu software como uma dependência no pom.xml. Aqui, utilizaremos a integração com um projeto Spring Boot para demonstrar sua funcionalidade.

Requisitos e Destaques

A biblioteca JLama requer Java 20+, pois faz uso da Vector API do Java. Para quem já utiliza LangChain, é possível integrá-lo ao JLama, aproveitando as ferramentas do LangChain para facilitar a interação com os modelos.

O projeto apresentado neste artigo consiste em dois endpoints que interagem com modelos LLM por meio de prompts:

Um endpoint configurado diretamente com JLama.
Outro endpoint utilizando LangChain em conjunto com JLama.

Implementação no Projeto

Endpoint com JLama

O primeiro endpoint configura diretamente a biblioteca JLama para gerar respostas baseadas em um prompt enviado pelo usuário.

@PostMapping("/jlama") // Endpoint para funcionalidade de chat com JLama
public ResponseEntity<ChatPromptResponse> chatJlama(@RequestBody ChatPromptRequest request) {
    PromptContext context;
    if (abstractModel.promptSupport().isPresent()) {
        context = abstractModel.promptSupport()
                .get()
                .builder()
                .addSystemMessage("You are a helpful chatbot who writes very short responses.")
                .addUserMessage(request.prompt())
                .build();
    } else {
        context = PromptContext.of(request.prompt());
    }

    System.out.println("Prompt: " + context.getPrompt() + "\n");
    Generator.Response response = abstractModel
            .generate(UUID.randomUUID(), context, 0.0f, 256, (s, f) -> {});
    System.out.println(response.responseText);

    return ResponseEntity.ok(new ChatPromptResponse(response.responseText));
}

Aqui, configuramos o modelo desejado. Caso ele não esteja disponível localmente, será feito o download automático para o diretório especificado. Em seguida, criamos o contexto do prompt e geramos a resposta usando o JLama.

// Definindo o modelo e diretório para caso não encontre baixar o modelo Hugging Face
String model = "tjake/Llama-3.2-1B-Instruct-JQ4";
String workingDirectory = "./models";

// Baixando (se necessário) ou buscando localmente o modelo
File localModelPath = new Downloader(workingDirectory, model).huggingFaceModel();

// Carregando o modelo
ModelSupport.loadModel(localModelPath, DType.F32, DType.I8);

Endpoint com LangChain e JLama

O segundo endpoint utiliza o LangChain, reduzindo a quantidade de código necessário para interagir com o JLama.

@PostMapping("/langchain")
public ResponseEntity<Object> chatLangChain(@RequestBody ChatPromptRequest request) {
    var model = JlamaChatModel.builder()
            .modelName("meta-llama/Llama-3.2-1B")
            .temperature(0.7f)
            .build();

    var promptResponse = model.generate(
                    SystemMessage.from("You are a helpful chatbot who writes the must possible short message."),
                    UserMessage.from(request.prompt()))
            .content()
            .text();

    System.out.println("\n" + promptResponse + "\n");

    return ResponseEntity.ok(promptResponse);
}

Com LangChain, definimos o modelo e os parâmetros diretamente no builder, simplificando a lógica de implementação.

Links e Referências

Este projeto foi inspirado pela palestra do professor Isidro no SouJava: Assista à palestra aqui.

Documentações úteis:

Conclusão

JLama e LangChain oferecem uma maneira poderosa de integrar modelos LLM em aplicações Java. Neste artigo, exploramos como configurar e utilizar essas ferramentas com Spring Boot para criar endpoints que processam prompts textuais de maneira eficiente.

E você? Já trabalhou com LLMs em projetos Java? Compartilhe seus desafios e aprendizados nos comentários!

Entendendo o Algoritmo QuickSort: Dividir para Conquistar

Lucas Oliveira — Mon, 20 Jan 2025 17:22:54 +0000

No mundo dos algoritmos, o QuickSort é um dos mais eficientes e amplamente utilizados. Ele se destaca pela sua habilidade de ordenar grandes volumes de dados de forma rápida e eficiente, graças à sua estratégia de Dividir para Conquistar (DC). Vamos explorar como o QuickSort funciona!

O que é QuickSort?

QuickSort é um algoritmo de ordenação que utiliza a estratégia de Dividir para Conquistar. Ele escolhe um elemento chamado pivô e divide a lista em dois subarrays: um com elementos menores que o pivô e outro com elementos maiores. A recursão é aplicada aos subarrays, até que a lista esteja completamente ordenada.

A escolha do pivô pode ser feita de várias maneiras. Por exemplo, uma abordagem simples é escolher o primeiro elemento da lista. No entanto, essa não é uma regra, e outras escolhas também podem ser feitas, dependendo do caso.

Etapas do QuickSort

1. Base da Recursão

Quando a lista tem 0 ou 1 elemento, ela já está ordenada, e o algoritmo não precisa fazer mais nada.
java

// Verifique se a lista tem 0 ou 1 elemento, que já está ordenada
if (integerList.isEmpty() || integerList.size() < 2) {
    return integerList;
}

2. Divisão da Lista:

O próximo passo é escolher um pivô e dividir a lista em dois subarrays: um com elementos menores e outro com elementos maiores que o pivô. O código abaixo mostra como isso pode ser feito:

var pivo = integerList.getFirst();
for (int i = 1; i < integerList.size(); i++) {
   if (integerList.get(i) <= pivo) {
      menores.add(integerList.get(i));
   }
   if (integerList.get(i) > pivo) {
      maiores.add(integerList.get(i));
   }
}

Importante: Observe que a comparação começa a partir de i=1, para evitar que o pivô seja colocado no subarray de menores.

3. Recursividade:

Agora, a recursividade entra em ação! O algoritmo chama a função quickSort novamente para os subarrays de menores e maiores, repetindo o processo até que a lista esteja ordenada. Aqui está o código para combinar os resultados:

var sorted = new ArrayList<>(quickSort(menores));
sorted.add(pivo);
sorted.addAll(quickSort(maiores));
return sorted;

A Complexidade do Algoritmo

O QuickSort tem uma notação Big O de O(n log n), o que significa que ele é muito eficiente, especialmente quando comparado a algoritmos como o Bubble Sort, que tem O(n²).
Nota: Esta explicação é uma adaptação do Capítulo 4 do livro Entendendo Algoritmos, de Aditya Bhargava. Reforço que pode haver falhas, então é sempre bom revisar o conteúdo!

Conclusão

O QuickSort é um algoritmo poderoso que utiliza recursão para ordenar listas de forma eficiente. Sua principal vantagem é o tempo de execução, que pode ser muito rápido em listas grandes, especialmente quando comparado a outros algoritmos de ordenação. Se você deseja entender mais profundamente a fundo, recomendo a leitura do livro Entendendo Algoritmos.

Já utilizou o QuickSort em algum projeto real? Compartilhe nos comentários!