Como Integrar IA Em Aplicações Java Sem Surtar: Aprendi Chorando E Agora Te Ensino Sorrindo
Quando eu estava começando o segundo semestre da faculdade e ainda tinha dificuldade em criar programas que fizessem mais que printar "Hello, World" na tela, um professor me surpreendeu com a seguinte notícia: a pedido da faculdade, teríamos que fazer um projeto com IA em Java. Na época (que não faz tanto tempo - fun fact: ainda estou na faculdade) eu fiquei em estado de choque. Java. Com IA.
Para quem ainda é novo na área e não experimentou a completa sensação de desespero que só a programação pode proporcionar, Java não é conhecida por ser uma linguagem "amigável", muito menos quando se trata de inteligência artificial (a queridinha do público é Python nesse aspecto).
Se passaram semanas sem obter progresso visível, apenas pouquíssimos tutoriais disponíveis e menos ainda que realmente ajudassem, telas de erro, StackOverflow, ChatGPT, Google, café e lágrimas.
A importância dessa habilidade
Por que estou contando essa história? Porque, apesar do sofrimento, a habilidade de integração de IA em projetos Java se tornou valiosíssima. Tenho colegas que conseguiram estágio e emprego por causa disso e agora agradecemos ao professor e a faculdade por essa oportunidade. Mas você não precisa sofrer que nem eu. Eu montei esse guia para isso.
Nesse guia você vai encontrar:
- Integrar sua aplicação Java com IA usando a API da Hugging Face
- Rodar modelos localmente com DJL (Deep Java Library)
- Utilizar grandes modelos de linguagem com LangChain4j e Ollama
Tudo bem simples e explicado direitinho para gerar o mínimo de lágrimas possível. Vamos nessa?
Método de integração 1: usando a API da Hugging Face
A Hugging Face oferece uma API que te permite acessar modelos poderosos (tipo BERT, GPT-like e companhia) com um simples POST em JSON. Sem precisar treinar nada, entender deep learning ou rodar CUDA em um notebook que não aguenta nem abrir o Chrome.
Tudo o que você precisa é: um token de acesso gratuito, uma URL de modelo (que eles mesmos fornecem), e algumas linhas de Java usando HttpClient. Nada de bibliotecas estranhas, threads místicas ou configurações cabalísticas.
É IA como serviço, no estilo “pedi, chegou”. Você manda um texto, o modelo devolve uma resposta e ninguém precisa chorar no processo, a não ser que o modelo detecte tristeza no seu input. Ainda não te convenci? Veja por si mesmo:
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class HuggingFaceExample {
public static void main(String[] args) throws Exception {
// Token da sua conta Hugging Face. É gratuito, mas sem ele a IA te ignora.
String token = "Bearer SEU_TOKEN_AQUI";
// O texto que vai ser analisado. Digite o que você quiser:
String inputJson = "{\"inputs\": \"HA HA HA Esse código finalmente funcionou!\"}";
// Requisição para a API (POST com JSON e token de autorização)
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english"))
.header("Authorization", token)
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(inputJson))
.build();
// Cria um cliente HTTP e manda a requisição
HttpClient client = HttpClient.newHttpClient();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
// Exibição da resposta da IA, geralmente vem em JSON, por exemplo: [{"label":"POSITIVE","score":0.99}]
System.out.println(response.body());
}
}
Eu te falei que era tranquilo. Algumas observações inofensivas:
- O modelo usado aqui é o distilbert-base-uncased-finetuned-sst-2-english, um modelo de análise de sentimento treinado com dados do Stanford Sentiment Treebank.
- Você pode trocar por qualquer outro modelo da Hugging Face que suporte Inference API. Eles têm modelos para tradução, resumo, preenchimento de texto e mais.
- O token da API é gratuito (yey!), mas com limite de uso, e você pode gerar um aqui.
Método 2: DJL - rodando IA local no Java
Se a ideia de depender da internet para sua IA te dá arrepios ou se você já cansou de esperar resposta de API porque a conexão resolveu tirar férias, DJL é a salvação. Essa biblioteca permite rodar modelos de IA direto na sua máquina dentro do seu projeto Java, sem precisar de mágicas nem dos magos do TensorFlow.
E o melhor? É quase um “IA plug and play”: você puxa um modelo pronto, roda, e em segundos "tcharam", aparece o resultado. Sem o clássico desespero de configurar ambiente, instalar CUDA ou duvidar se seu notebook é bom o suficiente (coitado). É IA local. Se o meu primeiro exemplo não te convenceu, tá aí o segundo pra te provar que dá para integrar inteligências artificiais com Java sem querer se mudar para uma fazenda no interior de Minas:
E como eu sei que pode acontecer, já estou falando antes pra não ouvir birra: não vai esquecer de colocar as dependências no pom.xml, hein?
<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
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.exemplo</groupId>
<artifactId>djl-sentimento</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- Core da DJL -->
<dependency>
<groupId>ai.djl</groupId>
<artifactId>api</artifactId>
<version>0.27.0</version>
</dependency>
<!-- DJL Engine padrão (PyTorch) -->
<dependency>
<groupId>ai.djl.pytorch</groupId>
<artifactId>pytorch-engine</artifactId>
<version>0.27.0</version>
</dependency>
<!-- Modelos prontos para NLP (Hugging Face) -->
<dependency>
<groupId>ai.djl.huggingface</groupId>
<artifactId>transformers</artifactId>
<version>0.27.0</version>
</dependency>
<!-- Utilitários como barra de progresso -->
<dependency>
<groupId>ai.djl</groupId>
<artifactId>basicdataset</artifactId>
<version>0.27.0</version>
</dependency>
</dependencies>
</project>
Agora que evitamos algumas crises existenciais, vamos para o código Java (que usa o DJL para carregar um modelo BERT treinado para análise de sentimento). Veja só:
import ai.djl.ModelException;
import ai.djl.inference.Predictor;
import ai.djl.modality.Classifications;
import ai.djl.repository.zoo.Criteria;
import ai.djl.repository.zoo.ModelZoo;
import ai.djl.repository.zoo.ZooModel;
import ai.djl.training.util.ProgressBar;
import ai.djl.translate.TranslateException;
import java.io.IOException;
public class DJLSentimentExample {
public static void main(String[] args) throws IOException, ModelException, TranslateException {
// Configuramos os critérios para carregar um modelo de análise de sentimento BERT
Criteria<String, Classifications> criteria = Criteria.builder()
.setTypes(String.class, Classifications.class)
.optApplication(ai.djl.Application.NLP.SENTIMENT_ANALYSIS)
.optProgress(new ProgressBar())
.build();
// Carregamos o modelo e criamos um "previsor" para gerar previsões
try (ZooModel<String, Classifications> model = ModelZoo.loadModel(criteria);
Predictor<String, Classifications> predictor = model.newPredictor()) {
// Aqui é a parte mais legal, digitee a frase que você quer analisar:
String texto = "quero ficar só comendo queijo minas!";
// O modelo faz a previsão (análise de sentimento)
Classifications resultado = predictor.predict(texto);
// Imprime o resultado, por exemplo: [positive: 0.97, negative: 0.03]
System.out.println(resultado);
}
}
}
Como minha mãe dizia depois de me levar para tomar vacina quando criança: "não doeu, né?" Agora você já sabe, mais informações inofensivas:
- A DJL baixa automaticamente o modelo correto e necessário.
- Não precisa configurar nada complexo, só ter internet para baixar o modelo na primeira execução (depois roda offline).
- O método predict recebe uma String (texto) e retorna uma classificação com as probabilidades para cada classe (positivo, negativo).
- É tão rápido que você nem vai ter tempo para chorar.
Outra coisa que minha mãe me dizia ao passar por processos traumáticos era: "tá acabando". O meu guia também está. Vamos ao terceiro e último método:
Método 3: LangChain4j com Ollama
Esse aqui é para quem não gosta de Python ou tem medo de acabar com toda a memória disponível com o node_modules. O LangChain4j chegou justamente pra isso: trazer o poder dos grandes modelos de linguagem (LLMs) para o Java com dignidade.
E a melhor parte? Ele funciona lindamente com o Ollama, uma ferramenta que roda modelos como llama, gemma e mistral localmente, sem sofrimento (dependendo da sua máquina talvez tenha um pouco de sofrimento se você tem muita ansiedade, eu não tenho culpa das IAs serem "pesadas"). Ainda assim, você pode possuir um assistente com IA conversando com você direto no seu projeto, sem precisar de chave de API, de graça, e com o controle 100% na sua mão. Sim, é real. Sim, funciona. (Por que você ainda duvida de mim? Depois de tudo o que eu mostrei aqui?)
Se você não prestou atenção, é importante, tipo muito, ter o Ollama instalado. E novamente, não esqueça de colocar as dependências no pom.xml
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>0.27.0</version>
</dependency>
Agora uma classe bem básica:
import dev.langchain4j.model.local.OllamaLanguageModel;
import dev.langchain4j.service.ChatLanguageModel;
public class LangChain4jOllamaExample {
public static void main(String[] args) {
// Conectando com o modelo Mistral rodando localmente via Ollama
ChatLanguageModel model = OllamaLanguageModel.builder()
.baseUrl("http://localhost:11434")
.modelName("mistral")
.build();
// Envia a pergunta para o modelo
String resposta = model.generate("Explique de forma simples o que é machine learning.");
// Exibe a resposta da IA
System.out.println(resposta);
}
}
Observações:
- Antes de rodar o código, certifique-se de que o modelo está ativo com: ollama run
- O exemplo faz uma pergunta só, mas dá pra transformar num chatbot fácil usando Scanner (mas isso pode ficar para outro dia).
- Esse setup roda 100% local e pode ser usado em qualquer app Java: de terminal até web ou desktop.
E acabou! Parabéns por ter chegado até o final, eu tenho certeza que tudo vai ficar bem. Realmente espero que esse guia possa ter te ajudado, que você possa testar os métodos e, quem sabe, utilizá-los em projetos maiores e realmente úteis.
Integrar IA com Java deixou de ser algo exclusivo de quem domina frameworks avançados ou tem anos de experiência. Hoje, existem formas acessíveis de trazer inteligência artificial para seus projetos, mesmo que você ainda esteja começando na programação.
Neste guia, vimos três métodos práticos: usando APIs externas (como a da Hugging Face), rodando modelos locais com DJL, e conectando-se a LLMs via LangChain4j com Ollama. Cada um tem suas vantagens, mas todos funcionam com Java puro. Esse simples diagrama exibe a comparação:
+-------------------+ +------------------+ +--------------------------+
| Hugging Face API | --> | Java HttpClient | --> | IA via Internet (JSON) |
+-------------------+ +------------------+ +--------------------------+
+-------------------+ +------------------+ +--------------------------+
| DJL | --> | Java | --> | Modelo Local (BERT) |
+-------------------+ +------------------+ +--------------------------+
+-------------------+ +------------------+ +--------------------------+
| LangChain4j | --> | Ollama + Java | --> | LLM Local (LLaMA3) |
+-------------------+ +------------------+ +--------------------------+
Entender essas opções é mais do que um exercício técnico: pode abrir caminhos no mundo profissional. E agora você tem um ponto de partida (mas por favor não me utilize como fonte absoluta de informação. Eu sou só uma estudante, lembra?)
Falando em fonte de informação, aqui estão as minhas referências:
