Olá, pessoal! Tudo bem? Para quem não me conhece, muito prazer. Eu sou o professor Isidro. É um orgulho para mim, uma grande honra poder estar com vocês aqui neste curso de Inteligência Artificial com Java usando LangChain4j.
Se você não me conhece, pode me seguir depois nas redes sociais. Basta me buscar como Professor Isidro que você me encontrará. Eu sou um dos 400 Java Champions no mundo, sendo um dos 18 brasileiros. E qual é a parte mais interessante de tudo isso? Muita gente me pergunta: “Isidro, Java com IA vale a pena?” Queremos, deixando as paixões de lado, trazer alguns aspectos técnicos para você.
O que queremos mostrar nesta primeira conversa, antes de irmos à parte prática? Para quem ainda tem a visão de que Java é atrasado, lento e verboso, queremos propor alguns pontos de reflexão. Se você está neste curso, muito provavelmente já é pessoa desenvolvedora Java, então muitos desses tópicos já devem estar claros. Ainda assim, se houver dúvidas, vamos esclarecer.
Primeiro ponto. Se você pensa que Java é lento, verboso e pesado, está pensando em um Java de, no mínimo, 15 a 20 anos atrás. Java evoluiu muito e segue evoluindo constantemente. O comitê que cuida da evolução da linguagem Java, o JCP (Java Community Process), trabalha com lançamentos semestrais. Todos os anos, em março e em setembro, temos novas versões de Java. O que isso implica? Em algumas versões, há modificações na linguagem, sempre com foco em retrocompatibilidade. Ou seja, não temos uma nova linguagem a cada seis meses; temos novas features (recursos) a cada seis meses. Isso mantém nossa base de código atualizada e nos permite incrementar nosso conhecimento e nossa caixa de ferramentas na própria linguagem de forma gradual.
Segundo ponto. Além dos avanços na linguagem — que nos afetam diretamente —, temos melhorias, correções e ganhos de desempenho na Máquina Virtual Java (JVM) em cada nova versão, incluindo modificações na gestão de memória. O que isso significa? Você pode perguntar: “O que isso significa, Isidro?” Significa que, se você tem um software rodando, por exemplo, em Java 17 e migra para a JVM 21, 25, 26 — não importa —, vai perceber ganhos de desempenho automaticamente. Sua aplicação não muda nada, mas a máquina virtual vem mais otimizada para executar mais rápido, consumir menos memória, ser mais eficiente e, eventualmente, corrigir potenciais bugs (erros) encontrados em versões anteriores. Isso é muito positivo, porque, antes dessa cadência semestral, havia intervalos longos entre atualizações do ecossistema Java. Agora, tanto a linguagem quanto a máquina virtual se atualizam constantemente, o que nos traz muitas vantagens.
Outro ponto. Existem ganhos concretos no uso de Java no ambiente corporativo, e aqui entra a pergunta: por que usar inteligência artificial com Java? Historicamente — e dizemos isso acompanhando a evolução de Java desde a versão 1.0, em 1995 —, o primeiro kit de ferramentas para aprendizado de máquina/IA surgiu em Java: Weka (W-E-K-A). Era um kit robusto e potente, no qual implementávamos diversas funcionalidades, cálculos, expressões aritméticas, estatística e tudo o que o aprendizado de máquina utiliza, tudo feito em Java.
Depois, com o surgimento das GPUs, o aprendizado de máquina migrou fortemente para uso intensivo de GPU, incluindo os modelos LLM atualmente. Existem, por exemplo, os frameworks (frameworks) CUDA e OpenCL, muito orientados a C e C++. Por isso, surgiu com força a linguagem Python, que usa esses frameworks (frameworks) e se integra muito bem a eles, de forma que programamos em Python e utilizamos bibliotecas em C e C++ para aproveitar as GPUs e ganhar desempenho no processamento de dados em GPU. Assim, Python despontou e se tornou muito usado para inteligência artificial e aprendizado de máquina.
Então, onde Java entra nessa história? Hoje contamos com novos frameworks (frameworks) de aprendizado de máquina em Java, um deles é o Tribuo, que é muito bom. Mas, principalmente, temos projetos integrados à própria JVM que permitem a execução em GPU de forma nativa. Podemos, por exemplo, explorar uma extensão da Máquina Virtual Java chamada TornadoVM, que é basicamente um plugin (extensão) instalado na máquina virtual. Escrevemos código Java e esse código é compilado para rodar na GPU. Isso é transformador porque agora podemos criar e executar LLMs, GPTs etc., localmente, na sua máquina — se houver GPU —, com os motores desses LLMs rodando em Java. É uma evolução tão grande que, como pessoa desenvolvedora Java, não precisamos aprender uma nova stack (pilha), um novo linguagem ou uma nova forma de programar para usar todas as potencialidades das ferramentas atuais de IA e criar nossos softwares, ferramentas e sistemas. Esse é o ponto mais interessante.
Queremos mostrar alguns aspectos práticos a respeito disso. Vamos compartilhar a tela rapidamente e apresentar alguns exemplos.
Por exemplo, para discutir se Java é lento ou não, existe o desafio em destaque na comunidade chamado One Billion Row Challenge (Desafio de Um Bilhão de Linhas). Quem desenvolveu esse desafio foi outro Java Champion, Gunnar Mörling. No primeiro desafio, precisamos processar um arquivo de um bilhão de linhas contendo o nome da cidade e as temperaturas mínima, máxima e média — basicamente, nome da cidade e temperatura. Algo como isto. Aqui está: encontramos o One Billion Row Challenge (Desafio de Um Bilhão de Linhas).
Precisamos criar um código Java que leia todo o arquivo e agrupe, por cidade, a temperatura máxima lida, a temperatura mínima lida e a temperatura média. Para quem está aprendendo programação, esse é um algoritmo clássico.
O ponto inesperado é o tempo de execução. Vamos apresentar alguns resultados. Em uma máquina com 32 núcleos, utilizando apenas 8, obtivemos tempos de execução de 1,5 s e 1,587 s usando GraalVM, a máquina virtual poliglota Java da Oracle. O primeiro resultado com o JDK padrão, o OpenJDK na versão Java 21, foi de 1,880 s. Ou seja, um arquivo de um bilhão de linhas, com cerca de 17 GB de tamanho, pode ser lido em menos de 2 segundos, processando e agrupando máxima, média e mínima de temperatura por cidade, sem grande esforço, inclusive com os códigos-fonte disponíveis.
Em seguida, ampliamos o cenário: disponibilizamos todos os processadores da infraestrutura para execução. Com 32 núcleos e 64 threads (cada núcleo com 2 threads), o tempo de execução foi de 0,323 s em GraalVM. O primeiro resultado com OpenJDK foi de 623 ms. Em menos de 1 segundo, o resultado já estava pronto. O que isso significa para nós? Java é realmente lento? Ao fazermos as coisas corretamente, com código bem projetado e implementado, é possível obter resultados impressionantes.
Sobre o que mencionamos anteriormente, o TornadoVM (tornadovm.org) permite instalar um plug-in na máquina virtual Java que executa código Java diretamente na GPU. Se tivermos um computador com GPU, podemos executar código Java nela. Há, inclusive, um teste público chamado “GPU Llama 3”: trata-se de um motor de inferência em Java, semelhante ao Llama 3 da Meta, integrável com LangChain4j, Quarkus e várias outras tecnologias. O ponto central é que podemos executar, entre aspas, um “GPT” localmente, sem assinar nenhum provedor. É possível visualizar o monitor de uso da GPU aumentando a carga conforme a inferência avança.
O terceiro projeto é o Tribuo (Tribuo Machine Learning em Java), um framework para aprendizagem de máquina, estatística e modelagem. É uma biblioteca em Java que oferece ferramentas para classificação, regressão, agrupamento, desenvolvimento de modelos e muito mais, tudo puramente em Java. Por que isso é relevante? Porque, quando nós, pessoas desenvolvedoras Java, precisávamos integrar com IA e aprendizado de máquina, recorríamos a Python, o que exigia configurar outro ambiente, aprender uma linguagem nova e lidar com diferenças de orientação a objetos. Agora, isso pode ser feito 100% em Java.
Do ponto de vista prático, o que ganhamos? No dia a dia, podemos manter a mesma base de código e o mesmo time: não precisamos de um time exclusivamente de aprendizado de máquina em Python e outro de Java para o back-end quando a solução já está em Java. Podemos evoluir o software existente e incorporar novas capacidades, tudo funcionando no mesmo repositório, se desejarmos. Também evitamos criar um módulo de aprendizado de máquina separado em Python (por exemplo, com FastAPI ou Django) para que a aplicação Java chame via REST API. Agora podemos fazer tudo 100% em Java.
A partir daqui começa nosso propósito neste curso. Nossa ideia é criar uma aplicação 100% Java que se comunique com LLMs como ChatGPT (OpenAI), Gemini (Google), Anthropic e Amazon Bedrock. Vamos construir uma aplicação Java que se integre com os principais modelos de linguagem e, a partir disso, extrair o melhor desses modelos para nossas aplicações.
Para isso, utilizaremos um framework extremamente versátil: uma portabilidade do LangChain para Java, o LangChain4j. A mascote é um periquito; na versão para Java, o periquito aparece tomando café. O LangChain4j tem integração com praticamente todos os LLMs do mercado: GPT, Gemini, Anthropic, Microsoft Copilot, entre outros. Ele consegue se comunicar com qualquer aplicação Java, em qualquer framework:
O principal é que teremos suporte a agentes, chamadas de função e RAG. Nosso objetivo prático será criar uma aplicação com um agente de software que converse com um modelo de linguagem (vamos escolher um) e realize ações por nós. Esse é o ponto central para começarmos a escrever o código.
Fiquemos atentos. Bem-vindos a esta jornada; vamos trabalhar intensamente na criação da nossa própria solução. Agradecemos!
[♪]
Vamos pensar em nossa aplicação e definir algo realmente útil. Isidro, gostaríamos de trabalhar com você usando IA nesta proposta.
Consideramos que o primeiro ponto é a saturação de conteúdo sobre IA com pouca prática aplicável ao dia a dia. Nosso objetivo aqui é criar um agente de software (programa) que funcione como assistente virtual.
Queremos mostrar um projeto que foi um sucesso no início de 2026: OpenClaw, um assistente de IA pessoal. Embora seja genérico e capaz de executar diversas tarefas, sua arquitetura é muito interessante e podemos aproveitá-la em nosso projeto.
O que é o OpenClaw? Basicamente, é um “cérebro” que se conecta a um provedor de LLM (Modelo de Linguagem Grande) para compreender as solicitações e integra diversos canais: Telegram, WhatsApp, Discord, Slack, interfaces em web (internet) e até linha de comando. Ele também pode acionar conectores, como o próprio WhatsApp para responder, GitHub para outras tarefas e assim por diante.
A vantagem para nosso contexto é extrair desse conceito o que é útil para o dia a dia: criar uma aplicação de escopo reduzido, porém completa. Vamos desenhar a arquitetura do nosso Alura OpenClaw.
Se estiverem acompanhando a tela, estamos utilizando o Draw.io como uma “lousa” para rascunhar a arquitetura. Inserimos um bloco representando um cérebro eletrônico: será o nosso Alura OpenClaw 4J, já batizado assim por ser implementado em Java.
Esse componente terá a capacidade de receber entradas de pessoas usuárias por algum canal e integrar-se a ferramentas, ao menos para organizar tarefas e funcionalidades relacionadas. Para isso, precisará comunicar-se com um provedor de LLM (Modelo de Linguagem Grande). Caso não haja um ícone da OpenAI disponível, utilizaremos temporariamente o do Gemini para representar o provedor; na prática, poderemos usar Gemini, OpenAI ou outro serviço equivalente. A ideia é implementar esse passo a passo de forma tranquila.
Quanto ao canal de comunicação, adotaremos o Telegram por ser mais simples de integrar. Não utilizaremos WhatsApp inicialmente porque ele exige uma aplicação homologada na Meta, o que complica o processo. Alternativamente, seria possível recorrer a um gateway (porta de entrada) de terceiros para viabilizar essa integração.
No Telegram, é possível criar um bot de forma muito mais ágil. Assim, o Telegram será o canal de comunicação para que possamos enviar as demandas ao nosso Alura OpenClaw4J, que interagirá com o Notion.
Vamos representar o Notion com a letra N. Para fins visuais, colocaremos essa letra em uma caixa e ajustaremos o tamanho para 45, com uma fonte adequada, como se fosse o ícone do Notion. Vocês têm acesso a essa arquitetura e a todo o material no conteúdo do curso.
A ideia é utilizarmos o Telegram para, por exemplo, pelo celular, enviar demandas que serão processadas no Notion, funcionando como nosso assistente pessoal.
Para isso, precisaremos realizar algumas configurações e implementar funcionalidades básicas no projeto. Trabalharemos passo a passo, criando elementos em etapas pequenas, para operarmos a arquitetura de forma prática, evolutiva e, principalmente, entendendo como incorporar cada um desses novos componentes.
A grande vantagem é que, ao enviarmos um prompt (instrução), uma pergunta ou uma demanda, esse “cérebro” precisará de uma configuração do modus operandi com o qual deve trabalhar. Vamos criar um arquivo agent.md, que é o prompt (instrução) de configuração do funcionamento. Nesse arquivo, incluiremos todas as instruções sobre o que pode e não pode fazer, como deve se comportar, quais são os limites de atuação, quais são as capacidades e como tratará a pessoa usuária. Por exemplo, poderíamos chamá-lo de Jarvis4J e definir como se referirá à pessoa usuária, como em: “Olá, Sr. Stark.” Isso é possível.
Além disso, para acessarmos o Notion, utilizaremos o recurso de Tool Calling (chamada a ferramentas) oferecido pelo modelo de linguagem utilizado. Teremos um conjunto de ferramentas integradas ao Notion — basicamente objetos e métodos —, e o nosso Alura OpenClaw4J (AOC4J) saberá, com base nas especificações do agent.md (o arquivo pode ter outro nome), quais são os métodos disponíveis nessas classes e, a partir disso, invocará as funcionalidades do Notion.
Com isso, teremos nossa arquitetura bem definida. Trabalhamos de forma gradual, incorporando cada funcionalidade para que possamos entender tudo o que está acontecendo. Compreendida minimamente essa arquitetura, começaremos o setup (configuração inicial) da aplicação.
Vamos colocar as mãos na massa.
Vamos abrir o IntelliJ, que será nossa IDE de trabalho. Aguardamos o IntelliJ iniciar. Vamos criar um novo projeto, acessando a opção do assistente em New Project (Novo Projeto). Configuraremos este projeto de forma tranquila. Será um projeto Java, que chamaremos de AluraAoc4j. Onde ficará? Teremos uma pasta chamada "Isidro". Essa pasta já havia sido criada, então está disponível.
Este será principalmente um projeto Maven. Por que escolher Maven? Porque precisaremos adicionar bibliotecas tanto para nos comunicarmos com os LLMs quanto com o Telegram e o Notion, e teremos de gerenciar todas essas dependências. Nada melhor do que usar o Maven como nosso gerenciador de dependências.
O JDK instalado aqui é o 21; 21, 25 ou 26 funcionarão exatamente da mesma forma. Em seguida, vamos em Advanced Settings (Configurações Avançadas) e definimos o Group como br.com.alura.aoc4j. Confirmamos em Create in this window (Criar nesta janela). O projeto está criado e organizado.
Se já estivermos habituados com o IntelliJ, veremos a pasta "src", dentro dela "main", e dentro de "main" a pasta "java". Nessa estrutura, manteremos nossos códigos organizados em pacotes. Vamos criar um pacote inicial para trabalharmos de forma tranquila.
Depois, em "resources" — isso é importante — colocaremos o arquivo agent.md. De acordo com nossa arquitetura, esse agent.md é o que instruirá o “cérebro” (o agente) sobre como trabalhar. Ele ficará disponível dentro dessa pasta "resources" para ser utilizado pelo projeto.
Para nos organizarmos, vamos criar um package chamado br.com.alura.aoc4j. Dentro desse package, criaremos nossa classe principal. É uma API Spring Boot? É uma aplicação Cloud Native com Quarkus? Ou é uma aplicação de linha de comando? Será uma aplicação de linha de comando, de forma simples, para mostrarmos que o LangChain4j é suficientemente poderoso para nos dar a versatilidade de criar uma aplicação de linha de comando e colocá-la em produção.
Ao criar a classe Java principal, começamos com a estrutura básica da classe:
package br.com.alura.aoc4j;
public class MainClass {
}
Vamos criar nossa classe Java, a classe principal. Vamos apenas aumentar um pouco o tamanho da fonte para ficar legível.
Se estivéssemos usando Java 25, poderíamos escrever apenas void main. Para ilustrar como ficaria, este seria o esqueleto do método:
package br.com.alura.aoc4j;
public class MainClass {
void main() {
}
}
Como estamos usando Java 21, adotaremos o cabeçalho padrão: public static void main(String[] args).
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
}
}
O que faremos neste projeto agora? Vamos adicionar um System.out para imprimir “AOC4j initializing”. Será um pequeno log apenas para verificarmos se está funcionando.
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
}
}
Salvamos o projeto e executamos. Vemos “AOC4j initializing”, então o ambiente está ok. Surgem algumas advertências por causa dos argumentos; ajustamos para o outro estilo recomendado para que o IntelliJ não aponte esses avisos. Não sejamos muito puristas em relação a isso.
Agora, queremos configurar algumas informações como variáveis de ambiente: a chave do LLM, a chave do Telegram e a chave do Notion. Como vamos integrar ferramentas externas que geralmente usam tokens de acesso, para não deixar isso hardcoded (fixado no código), faremos uma configuração mais segura por meio de variáveis de ambiente. Depois, no seu ambiente, basta alterar esses valores.
Como fazemos isso? No IntelliJ, vamos criar uma configuração de execução. Se estivermos no Eclipse, vamos em Build Path (Caminho de Build) e Run Configurations (Configurações de Execução). No IntelliJ, acessamos Edit Configurations (Editar Configurações) e criamos uma nova configuração para nossa aplicação Java. Vamos chamá-la de AOC4JConfig. Precisamos indicar que é Java 21. Qual é a classe principal? É a classe principal que contém o método main.
Aqui está o ponto essencial: em Environment Variables (Variáveis de Ambiente), vamos criar algumas variáveis. Depois, obviamente, substituiremos pelos valores reais. Em User Environment Variables (Variáveis de Ambiente do Usuário), adicionamos uma variável; inicialmente poderíamos chamá-la de TST, com o valor “Welcome to AOC4J”, e em seguida renomeamos para Greetings. Pronto: essa variável de ambiente está configurada.
Confirmamos a configuração e definimos a variável de ambiente GREETINGS como “Welcome to AOC4J”. Aplicamos as alterações e fechamos a janela.
A partir disso, criamos uma função que lê essa variável de ambiente para verificar se realmente funciona. Definimos a String msg utilizando System.getenv com o nome da variável GREETINGS. Se funcionar, imprimimos msg. Isso significa que o programa leu a configuração armazenada na variável de ambiente e exibiu seu conteúdo com a configuração definida.
Primeiro, vamos ler a variável de ambiente:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
}
}
Em seguida, imprimimos o conteúdo lido para validar:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
}
}
Ao executar, a saída exibiu: “Olá! Welcome to AOC4J”. Pronto. O preparo inicial da nossa aplicação está concluído e estamos corretos.
O que faremos agora? Vamos por partes, para trabalhar de forma gradual e entender como integrar cada elemento.
Passo número 1: o que queremos fazer? Vamos deixar de lado, por enquanto, o AGMD e o Colin. Mantemos essa parte destacada em cinza apenas para indicar que não vamos alterá-la agora. Nosso foco aqui é implementar a comunicação do AOC4J com a nossa LLM (Large Language Model, Modelo de Linguagem Ampla). Como faremos isso? Primeiramente, precisamos de um componente que intermedeie essa comunicação; quem fará essa ponte é a biblioteca LangChain4j. É ela que vai intermediar a comunicação.
De que maneira configuramos isso? Precisamos ir ao repositório para buscar as dependências do projeto. Dentro do projeto, há um arquivo chamado pom.xml. Esse arquivo .xml concentra as configurações iniciais das bibliotecas que vamos utilizar. Especificamos o identificador do projeto como br.com.alura.aoc4j, a versão como 1.0-SNAPSHOT, a versão do compilador Java nas propriedades e, em seguida, criamos a seção de dependências (Dependencies).
Primeiro, deixamos o pom.xml com as propriedades do compilador e a seção de dependências vazia:
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
</dependencies>
</project>
Em seguida, marcamos que vamos adicionar o LangChain4j:
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- langchain4j -->
</dependencies>
</project>
Como tudo isso funciona? Acessamos o site do Maven Repository (mvnrepository.com), pesquisamos por “langchain4j” e, neste caso, precisaremos de duas bibliotecas: “langchain4j” e “langchain4j-open-ai” (no Maven, o artefato é escrito com hífen: langchain4j-open-ai). Selecionamos a versão desejada; embora existam versões mais recentes, utilizaremos a 1.13.0, que é bastante popular. Copiamos o trecho de configuração na aba Maven e colamos na seção de dependências do pom.xml. Salvamos. Em seguida, atualizamos o projeto para que as bibliotecas sejam baixadas e reconhecidas pelo código.
Primeiro adicionamos o núcleo do LangChain4j:
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- langchain4j -->
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>1.13.0</version>
</dependency>
</dependencies>
</project>
Depois repetimos o procedimento para o conector com a OpenAI, na mesma versão 1.13.0:
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- langchain4j -->
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>1.13.0</version>
</dependency>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-open-ai</artifactId>
<version>1.13.0</version>
</dependency>
</dependencies>
</project>
Em alguns casos, o site pode solicitar verificação do tipo “Não sou um robô”, o que é normal. Depois disso, carregamos as mudanças do Maven para baixar todas as bibliotecas e usá-las no código. A partir daí, podemos utilizar LangChain4j no projeto.
Agora, se quisermos trabalhar com OpenAI do nosso jeito, como fazemos? Primeira coisa: a OpenAI oferece basicamente dois grandes produtos. O primeiro é o ChatGPT (interface web), acessível em chatgpt.com. O segundo é a API (interface de programação de aplicações) da OpenAI, que permite criar uma aplicação externa utilizando os modelos da OpenAI como motores de processamento de linguagem — que é o nosso caso. Para isso, precisamos disponibilizar tokens (unidades de uso) sob demanda.
Como funciona? Para usar uma LLM, precisamos adquirir créditos de tokens. É necessário um cartão de crédito. A vantagem é que podemos colocar, por exemplo, 5 dólares — que, na cotação atual, equivale a algo entre 20 e 25 reais — e usar uma boa quantidade de tokens até que se esgotem. Acessamos platform.openai.com, fazemos login (autenticação) com nossa conta e seguimos.
Estando autenticados, veremos o saldo de créditos disponível. Em seguida, geramos uma chave de API (CREATE API KEY). A ideia é utilizar essa chave no projeto por meio de uma variável de ambiente. Damos um nome para a chave, por exemplo, “EOC4J”, e ela terá permissões amplas. Copiamos a chave imediatamente, pois, ao fechar a janela, não será possível recuperá-la; é necessário armazená-la com segurança. Feito isso, vamos às configurações do projeto e adicionamos uma variável de ambiente chamada OPENAI_API_KEY, colando o valor da chave copiada. Observamos que a chave geralmente começa com “sk_proj_…”. Aplicamos e fechamos as configurações.
Agora vamos criar nosso modelo de chat para fazer uma pergunta simples à OpenAI e verificar se está funcionando. Definimos um OpenAiChatModel por meio de um builder, especificando a apiKey obtida do ambiente. Para isso, antes definimos a variável local OPENAI_KEY com System.getenv("OPENAI_API_KEY") e a repassamos ao builder. Em seguida, configuramos o nome do modelo (modelName). Há um enumerador, OpenAiChatModelName, que lista modelos como gpt-3.5, gpt-4, gpt-4.1, gpt-4.1-mini, entre outros disponíveis. Para o que queremos fazer aqui, o mínimo recomendado é utilizar um modelo da família 4; o 3.5 não atende. Vamos escolher o gpt-4.1.
Também podemos ajustar a temperatura (temperature). Em geral, um valor próximo de 0,5 ajuda quando buscamos mais variedade nas respostas. Quanto menor a temperatura, maior a previsibilidade do resultado. A temperatura varia de 0 a 1 e indica o quanto a IA pode ser criativa. Se estivermos gerando textos criativos, aumentamos esse valor; se quisermos aplicações com comportamento mais determinístico — interpretar e cumprir estritamente as instruções —, reduzimos a temperatura para tornar o modelo mais assertivo e previsível. Depois concluímos a configuração com build().
Com o modelo configurado — comunicação com a OpenAI via chave de API, utilizando o modelo gpt-4.1 e com criatividade controlada —, preparamos um prompt de teste, por exemplo: “Qual é a fórmula da água?”. Em seguida, chamamos chat.chat(prompt) para obter a resposta e a exibimos no console.
Agora, vamos inserir esse código progressivamente, passo a passo:
Primeiro, iniciamos o builder do OpenAiChatModel dentro do nosso main:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
OpenAiChatModel chat = OpenAiChatModel.builder()
}
}
Em seguida, indicamos que iremos configurar a chave da API (ainda sem o valor):
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
OpenAiChatModel chat = OpenAiChatModel.builder()
.apiKey()
}
}
Agora, buscamos a variável de ambiente OPENAI_API_KEY:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
String OPENAI_API_KEY = System.getenv("OPENAI_API_KEY");
OpenAiChatModel chat = OpenAiChatModel.builder()
.apiKey()
}
}
E passamos essa chave para o builder:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
String OPENAI_API_KEY = System.getenv("OPENAI_API_KEY");
OpenAiChatModel chat = OpenAiChatModel.builder()
.apiKey(OPENAI_API_KEY)
}
}
Na escolha do modelo, o enumerador oferece várias opções da família 4. No código abaixo, usamos GPT_4_O (GPT-4o) como exemplo — você também pode optar por GPT_4_1 de acordo com sua necessidade:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
String OPENAI_API_KEY = System.getenv("OPENAI_API_KEY");
OpenAiChatModel chat = OpenAiChatModel.builder()
.apiKey(OPENAI_API_KEY)
.modelName(OpenAiChatModelName.GPT_4_O)
}
}
Ajustamos a temperatura. Embora tenhamos discutido valores em torno de 0,5 para mais variedade, neste exemplo deixamos como 0,2 para respostas mais determinísticas:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
String OPENAI_API_KEY = System.getenv("OPENAI_API_KEY");
OpenAiChatModel chat = OpenAiChatModel.builder()
.apiKey(OPENAI_API_KEY)
.modelName(OpenAiChatModelName.GPT_4_O)
.temperature(0.2)
}
}
Concluímos com build() para obter a instância configurada:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
String OPENAI_API_KEY = System.getenv("OPENAI_API_KEY");
OpenAiChatModel chat = OpenAiChatModel.builder()
.apiKey(OPENAI_API_KEY)
.modelName(OpenAiChatModelName.GPT_4_O)
.temperature(0.2)
.build();
}
}
Com o modelo pronto, definimos um prompt de teste para validar a comunicação:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
String OPENAI_API_KEY = System.getenv("OPENAI_API_KEY");
OpenAiChatModel chat = OpenAiChatModel.builder()
.apiKey(OPENAI_API_KEY)
.modelName(OpenAiChatModelName.GPT_4_O)
.temperature(0.2)
.build();
String prompt = "Qual a formula da agua?";
}
}
Por fim, enviamos a mensagem ao modelo e exibimos a resposta no console:
package br.com.alura.aoc4j;
public class MainClass {
public static void main(String[] args) {
System.out.println("AOC4J - Initializing...");
String msg = System.getenv("GREETINGS");
System.out.println(msg);
String OPENAI_API_KEY = System.getenv("OPENAI_API_KEY");
OpenAiChatModel chat = OpenAiChatModel.builder()
.apiKey(OPENAI_API_KEY)
.modelName(OpenAiChatModelName.GPT_4_O)
.temperature(0.2)
.build();
String prompt = "Qual a formula da agua?";
System.out.println("Resposta: " + chat.chat(prompt));
}
}
Salvamos tudo e executamos. A primeira execução pode demorar um pouco. A resposta retornada foi: “A fórmula da água é H2O. Isso significa que cada molécula de água é composta por…”. Ou seja, conseguimos conversar com a OpenAI a partir da nossa aplicação. Voltando ao nosso diagrama, essa comunicação começou a ser viabilizada. Excelente.
Encerramos essa primeira parte do conteúdo. Agora, vamos evoluir a implementação e observar como tudo funciona em conjunto.
O curso LangChain4j: desenvolvimento de agentes de IA em Java possui 227 minutos de vídeos, em um total de 28 atividades. Gostou? Conheça nossos outros cursos de Java em Back-end, ou leia nossos artigos de Back-end.
Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:
O Plano Plus evoluiu: agora com Luri para impulsionar sua carreira com os melhores cursos e acesso à maior comunidade tech.
2 anos de Alura
Matricule-se no plano PLUS 24 e garanta:
Jornada de estudos progressiva que te guia desde os fundamentos até a atuação prática. Você acompanha sua evolução, entende os próximos passos e se aprofunda nos conteúdos com quem é referência no mercado.
Back-end, Dados, Front-end, DevOps, Mobile, Gestão & Negócios, UX & Design, Cibersegurança, Cloud, Inteligência Artificial
Formações com mais de 1500 cursos atualizados e novos lançamentos semanais, em Programação, Inteligência Artificial, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.
A cada curso ou formação concluído, um novo certificado para turbinar seu currículo e LinkedIn.
Acesso à inteligência artificial da Alura.
No Discord, você participa de eventos exclusivos, pode tirar dúvidas em estudos colaborativos e ainda conta com mentorias em grupo com especialistas de diversas áreas.
Catálogo de tecnologia para quem é da área de Marketing
Faça parte da maior comunidade Dev do país e crie conexões com mais de 120 mil pessoas no Discord.
Acesso ilimitado ao catálogo de Imersões da Alura para praticar conhecimentos em diferentes áreas.
Explore um universo de possibilidades na palma da sua mão. Baixe as aulas para assistir offline, onde e quando quiser.
20% de desconto na Pós Tech
Luri Vision chegou no Plano Pro: a IA da Alura que enxerga suas dúvidas, acelera seu aprendizado e conta também com o Alura Língua que prepara você para competir no mercado internacional.
2 anos de Alura
Todos os benefícios do PLUS 24 e mais vantagens exclusivas:
Acesso ao catálogo da Casa do Código e leitura dentro da plataforma
Chat, busca, exercícios abertos, revisão de aula, geração de legenda para certificado.
Modo entrevista - Pratique situações reais e evolua com feedback personalizado
Envie imagens para a Luri e ela te ajuda a solucionar problemas, identificar erros, esclarecer gráficos, analisar design e muito mais.
Aprenda um novo idioma e expanda seus horizontes profissionais. Cursos de Inglês, Espanhol e Inglês para Devs, 100% focado em tecnologia.
Para quem quer atingir seus objetivos mais rápido: Luri Vision ilimitado, vagas de emprego exclusivas e mentorias para acelerar cada etapa da jornada.
2 anos de Alura
Todos os benefícios do PRO 24 e mais vantagens exclusivas:
Lives CareerUp: eventos exclusivos com foco em empregabilidade e carreira
Mentorias de carreira: 2 encontros individuais com mentores do Talent Lab
Conecte-se ao mercado com mentoria individual personalizada, vagas exclusivas e networking estratégico que impulsionam sua carreira tech para o próximo nível.
