The recent 0.2.0 release of Google’s Agent Development Kit (ADK) for Java adds an integration with the LangChain4j LLM framework. This integration provides developers with a wide range of Large Language Models (LLMs) supported by LangChain4j, for building AI agents.
In addition to ADK’s built-in Google Gemini and Anthropic Claude integrations, developers can now use LangChain4j to access other models from third-party providers (like OpenAI, Anthropic, GitHub, Mistral...) or local open-weight models, e.g. via Ollama or Docker Model Runner.
The LangChain4j LLM framework supports a wide variety of models. You can check the list of supported models in the LangChain4j documentation. Let’s have a look at a couple concrete examples, using Gemma with Docker Model Runner, and Ollama with Qwen.
When declaring your ADK agent with the LlmAgent builder, you specify the LLM via the model() builder method. You usually pass a string representing the name of the model, like "gemini-2.5-flash".
It’s also possible to use an instance of a class extending the BaseLlm abstract class. This is exactly what the integration with LangChain4j does, to create a bridge between both frameworks. You have to use a new LangChain4j class that extends this BaseLlm class.
After having installed and enabled Docker Model Runner on your machine, you can pull the Gemma 3 model easily via this command:
docker model pull ai/gemma3As Docker Model Runner models exposes an OpenAI compatible API surface, you can use the LangChain4j module for OpenAI compatible models, by specifying the following dependencies in your Maven pom.xml:
<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>Then, create a LangChain4j chat model, specifying the model you want to use, and the local URL and port:
OpenAiChatModel dmrChatModel = OpenAiChatModel.builder()
.baseUrl("http://localhost:12434/engines/llama.cpp/v1")
.modelName("ai/gemma3n")
.build();Now, configure a chess coach agent using that model:
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();Notice how the bridge between the two frameworks is done via the model(new LangChain4j(dmrChatModel)) instruction. And here you go, your AI agent is powered by a local model!
If instead you want to build a friendly science teacher agent with the Qwen 3 model running locally on your machine via Ollama, first, define our dependencies inside a Maven pom.xml build file:
<!-- 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>Let’s assume you’ve already installed Ollama on your machine, you pulled the Qwen 3 model, and got it running on port 11434. With LangChain4j, in Java, you instantiate the Ollama model provider as follows:
OllamaChatModel ollamaChatModel = OllamaChatModel.builder()
.modelName("qwen3:1.7b")
.baseUrl("http://127.0.0.1:11434")
.build();Now let’s wire this model into a simple science teacher agent:
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();If the model supports function calling, you can give your agent access to tools as well. For example, give it access to MCP servers, or your local code driven functions. You can explore the various tools at your disposal in this article diving into ADK tools, or by looking at the ADK documentation.
Beyond the headline LangChain4j integration, version 0.2.0 brings several other powerful enhancements to the agent development workflow:
FunctionTools: You can now create FunctionTools from object instances, not just static methods, offering greater flexibility in your agent's architecture.FunctionTools now support methods that return a Single. This improves asynchronous operation support and makes agents more responsive.endInvocation field in Event Actions allows programmatic interruption or stopping of the agent loop after a tool call. This provides finer control over agent execution.before/after events on model, agent, and tool execution. This enables more complex and fine-grained logic within your agent's lifecycle.InMemoryMemoryService for simple, fast memory management and implements VertexAiRagRetrieval using AI Platform APIs for more advanced RAG patterns../mvnw), ensuring a consistent and straightforward build process for all contributors.We're thrilled to get this new version into your hands. The integration with LangChain4j marks a major step forward in making ADK for Java a more open and flexible framework for building powerful AI agents.
To learn more about this new version of ADK for Java, read the GitHub release notes. New to developing agents in Java with ADK? Check out the ADK for Java documentation, this getting started guide (and video), or fork this GitHub template project to begin quickly.
My colleague Michael Vorburger and myself have been happy to work on this LangChain4j integration, in collaboration with Dmytro Liubarskyi who created LangChain4j. So if you’re building AI agents in Java with ADK, don’t hesitate to drop us a message to @glaforge on Twitter/X or @glaforge.dev on Bluesky. We’re looking forward to hearing about your great use cases.
Train a GPT2 model with JAX on TPU for free
Beyond backpropagation: JAX's symbolic power unlocks new frontiers in scientific computing
From Fine-Tuning to Production: A Scalable Embedding Pipeline with Dataflow
Gemini Batch API now supports Embeddings and OpenAI Compatibility