Abertura do ADK para Java para modelos de linguagem de terceiros via integração com o LangChain4j

16 DE SETEMBRO DE 2025

A recente versão 0.2.0 do Agent Development Kit (ADK) para Java do Google adiciona uma integração com o framework de LLM LangChain4j. Essa integração fornece aos desenvolvedores uma ampla gama de modelos de linguagem grandes (LLMs) com suporte no LangChain4j para a criação de agentes de IA.

Além das integrações incorporadas do ADK ao Google Gemini e ao Anthropic Claude, os desenvolvedores agora podem usar o LangChain4j para acessar outros modelos de terceiros (como OpenAI, Anthropic, GitHub, Mistral...) ou modelos locais de peso aberto, por exemplo, via Ollama ou Docker Model Runner.

Integração com o LangChain4j para uma grande variedade de modelos

O framework de LLM LangChain4j dá suporte a uma ampla variedade de modelos. Você pode conferir a lista de modelos com suporte na documentação do LangChain4j. Vamos dar uma olhada em alguns exemplos concretos, usando o Gemma com o Docker Model Runner e o Ollama com o Qwen.

Ao declarar um agente do ADK com o builder LlmAgent, você especifica o LLM usando o método builder model(). Geralmente, é transmitida uma string que representa o nome do modelo, como "gemini-2.5-flash".

Também é possível usar uma instância de uma classe que estende a classe abstrata BaseLlm. É exatamente isso que a integração com o LangChain4j faz para criar uma ponte entre os dois frameworks. Você deve usar uma nova classe LangChain4j que estende essa classe BaseLlm.

Execução do Gemma 3 com o Docker Model Runner

Depois de instalar e ativar o Docker Model Runner na máquina, você pode baixar o modelo Gemma 3 facilmente com este comando:

docker model pull ai/gemma3

Shell

Como os modelos Docker Model Runner expõem uma plataforma de API compatível com OpenAI, é possível usar o módulo LangChain4j para modelos compatíveis com OpenAI especificando as seguintes dependências no pom.xml do Maven:

<dependency>
    <groupId>com.google.adk</groupId>
    <artifactId>google-adk-contrib-langchain4j</artifactId>
    <version>0.2.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>1.4.0</version>
</dependency>

XML

Em seguida, crie um modelo de chat do LangChain4j, especificando o modelo que você deseja usar, o URL local e a porta:

OpenAiChatModel dmrChatModel = OpenAiChatModel.builder()
    .baseUrl("http://localhost:12434/engines/llama.cpp/v1")
    .modelName("ai/gemma3n")
    .build();

Java

Depois, configure um agente instrutor de xadrez usando esse modelo:

LlmAgent chessCoachAgent = LlmAgent.builder()
    .name("chess-coach")
    .description("Chess coach agent")
    .model(new LangChain4j(dmrChatModel))
    .instruction("""
        You are a knowledgeable chess coach
        who helps chess players train and sharpen their chess skills.
        """)
    .build();

Java

Observe como a ponte entre os dois frameworks é feita por meio da instrução model(new LangChain4j(dmrChatModel)). Pronto! O agente de IA está habilitado por um modelo local!

Execução do Qwen 3 com o Ollama

Se, em vez disso, você quiser criar um agente professor de ciências amigável com o modelo Qwen 3 executado localmente na máquina via Ollama, primeiro defina as dependências dentro de um arquivo de compilação pom.xml do Maven:

<!-- the code ADK framework -->
<dependency>
    <groupId>com.google.adk</groupId>
    <artifactId>google-adk</artifactId>
    <version>0.2.0</version>
</dependency>
<!-- the LangChain4j integration -->
<dependency>
    <groupId>com.google.adk</groupId>
    <artifactId>google-adk-contrib-langchain4j</artifactId>
    <version>0.2.0</version>
</dependency>
<!-- the LangChain4j Ollama provider -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-ollama</artifactId>
    <version>1.4.0</version>
</dependency>

XML

Vamos supor que você já tenha instalado o Ollama na máquina, baixado o modelo Qwen 3 e o colocado em execução na porta 11434. Com o LangChain4j, em Java, você instancia o provedor do modelo Ollama da seguinte forma:

OllamaChatModel ollamaChatModel = OllamaChatModel.builder()
    .modelName("qwen3:1.7b")
    .baseUrl("http://127.0.0.1:11434")
    .build();

Java

Agora, vamos conectar esse modelo a um agente professor de ciências simples:

LlmAgent scienceTeacherAgent = LlmAgent.builder()
    .name("science-app")
    .description("Science teacher agent")
    .model(new LangChain4j(ollamaChatModel))
    .instruction("""
        You are a helpful science teacher
        who explains science concepts to kids and teenagers.
        """)
    .build();

Java

Se o modelo oferecer suporte a chamadas de função, você também poderá dar acesso às ferramentas ao seu agente. Por exemplo, dê a ele acesso a servidores MCP ou às suas funções orientadas pelo código local. Você pode explorar as várias ferramentas à sua disposição neste artigo que detalha as ferramentas do ADK ou consultando a documentação do ADK.

Novos recursos nesta versão

Além da integração com o LangChain4j, a versão 0.2.0 traz várias outras melhorias poderosas para o fluxo de trabalho de desenvolvimento de agentes:

Recursos expandidos para ferramentas: melhoramos significativamente a forma como você cria e gerencia ferramentas.
- FunctionTools baseadas em instâncias: agora, você pode criar FunctionTools a partir de instâncias de objetos, e não simples métodos estáticos, o que oferece mais flexibilidade na arquitetura dos agentes.
- Suporte assíncrono aprimorado: agora, as FunctionTools dão suporte a métodos que retornam um Single. Isso melhora o suporte a operações assíncronas e torna os agentes mais responsivos.
- Controle maior das repetições: o novo campo endInvocation em Event Actions permite a interrupção programática ou a parada da repetição do agente após uma chamada de ferramenta. Isso proporciona um controle maior sobre a execução dos agentes.
Lógica e memória de agentes avançadas:
- Callbacks encadeados: adicionamos o suporte a callbacks encadeados para eventos before/after na execução de modelos, agentes e ferramentas. Isso permite uma lógica mais complexa e refinada dentro do ciclo de vida dos agentes.
- Nova memória e recuperação: esta versão introduz um InMemoryMemoryService para o gerenciamento simplificado e rápido da memória e implementa o VertexAiRagRetrieval usando APIs AI Platform para padrões de RAG mais avançados.
Outras melhorias importantes incluem um POM pai e o Maven Wrapper (./mvnw), garantindo um processo de compilação consistente e direto para todos os colaboradores.

Vamos colocar esses agentes de IA para trabalhar

É um prazer entregar esta nova versão a você. A integração com o LangChain4j marca um grande avanço para fazer do ADK para Java um framework mais aberto e flexível para a criação de agentes de IA poderosos.

Para saber mais sobre esta nova versão do ADK para Java, leia as notas da versão no GitHub. Está começando no desenvolvimento de agentes em Java com o ADK? Confira a documentação do ADK para Java, este guia (e vídeo) de primeiros passos ou bifurque este projeto de modelo do GitHub para começar rapidamente.

Meu colega Michael Vorburger e eu ficamos felizes em trabalhar nesta integração com o LangChain4j em colaboração com Dmytro Liubarskyi, criador do LangChain4j. Portanto, se você estiver criando agentes de IA em Java com o ADK, não hesite em nos enviar uma mensagem para @glaforge no Twitter/X ou para @glaforge.dev no Bluesky. Mal podemos esperar para conhecer seus ótimos casos de uso.

postado em: