La reciente versión 0.2.0 del Agent Development Kit (ADK) de Google para Java agrega una integración con el marco de trabajo de LLM LangChain4j. Esta integración proporciona a los desarrolladores una amplia gama de modelos de lenguaje grandes (LLM) compatibles con LangChain4j, para crear agentes de IA.
Además de las integraciones de Google Gemini y Anthropic Claude incorporadas en el ADK, los desarrolladores ahora pueden usar LangChain4j para acceder a otros modelos de proveedores externos (como OpenAI, Anthropic, GitHub, Mistral...) o modelos locales de peso abierto; p. ej., a través de Ollama o Docker Model Runner.
El marco de trabajo de LLM LangChain4j admite una amplia variedad de modelos. Puedes consultar la lista de modelos compatibles en la documentación de LangChain4j. Veamos un par de ejemplos concretos, como Gemma con Docker Model Runner y Ollama con Qwen.
Cuando declaras tu agente de ADK con el compilador LlmAgent
, especificas el LLM a través del método del compilador model()
. Por lo general, pasas una cadena que representa el nombre del modelo, como “gemini-2.5-flash
”.
También se puede usar una instancia de una clase que extienda la clase abstracta BaseLlm
. Esto es exactamente lo que hace la integración con LangChain4j para crear un puente entre ambos marcos de trabajo. Debes usar una nueva clase LangChain4j
que extienda esta clase BaseLlm
.
Después de instalar y activar Docker Model Runner en tu máquina, puedes extraer fácilmente el modelo Gemma 3 a través de este comando:
docker model pull ai/gemma3
Como los modelos de Docker Model Runner exponen una superficie de API compatible con OpenAI, puedes usar el módulo LangChain4j en modelos compatibles con OpenAI, especificando las siguientes dependencias en tu archivo pom.xml
de 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>
Luego, crea un modelo de chat LangChain4j y especifica el modelo que deseas usar, además de la URL local y el puerto:
OpenAiChatModel dmrChatModel = OpenAiChatModel.builder()
.baseUrl("http://localhost:12434/engines/llama.cpp/v1")
.modelName("ai/gemma3n")
.build();
Ahora, configura un agente de entrenador de ajedrez usando ese 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();
Observa cómo el puente entre los dos marcos de trabajo se realiza a través de la instrucción model(new LangChain4j (dmrChatModel))
. Y listo; tu agente de IA funciona con un modelo local.
Si quieres crear un agente de profesora de ciencias amistosa con el modelo Qwen 3 que se ejecuta localmente en tu máquina a través de Ollama, primero define nuestras dependencias dentro de un archivo de compilación pom.xml de 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>
Supongamos que ya instalaste Ollama en tu máquina, tomaste el modelo Qwen 3 y lo ejecutaste en el puerto 11434
. Con LangChain4j, en Java, crea una instancia del proveedor del modelo Ollama de la siguiente manera:
OllamaChatModel ollamaChatModel = OllamaChatModel.builder()
.modelName("qwen3:1.7b")
.baseUrl("http://127.0.0.1:11434")
.build();
Ahora, convirtamos este modelo en un simple agente de profesora de ciencias:
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();
Si el modelo admite la llamada a función, también puedes darle a tu agente acceso a las herramientas. Por ejemplo, otórgale acceso a los servidores MCP o a tus funciones locales basadas en código. Puedes explorar las diversas herramientas a tu disposición en este artículo sobre las herramientas del ADK o consultando la documentación del ADK.
Además de la integración de LangChain4j, la versión 0.2.0 incluye varias mejoras poderosas del flujo de trabajo de desarrollo de agentes:
FunctionTools
basadas en instancias: Ahora puedes crear FunctionTools
a partir de instancias de objetos, no solo de métodos estáticos, lo que ofrece una mayor flexibilidad en la arquitectura de tu agente.FunctionTools
ahora admite métodos que devuelven un objeto Single
. De esta manera, se mejora el soporte de operaciones asíncronas y los agentes son más responsivos.endInvocation
de acciones de eventos permite la interrupción o detención programática del bucle del agente después de una llamada a la herramienta. Así, se proporciona un control más exacto de la ejecución del agente.antes/después
en la ejecución de modelos, agentes y herramientas. Esto permite alcanzar una lógica más compleja y detallada dentro del ciclo de vida del agente.InMemoryMemoryService
para una administración de memoria simple y rápida e implementa VertexAiRagRetrieval
utilizando APIs de AI Platform para patrones de RAG más avanzados../mvnw
), lo que garantiza un proceso de compilación coherente y sencillo para todos los colaboradores.Nos encanta que tengas ya puedas probar esta nueva versión. La integración con LangChain4j es un gran avance en nuestra búsqueda de que el ADK para Java sea un marco de trabajo más abierto y flexible para crear agentes de IA poderosos.
Si deseas obtener más información sobre esta nueva versión del ADK para Java, lee las notas de la versión de GitHub. ¿No tienes experiencia en el desarrollo de agentes en Java con el ADK? Echa un vistazo a la documentación del ADK para Java, esta guía de introducción (y video), o bifurca este proyecto de plantilla de GitHub para comenzar a experimentar rápidamente.
Mi colega Michael Vorburger y yo estamos encantados de trabajar en esta integración de LangChain4j, en colaboración con Dmytro Liubarskyi, quien creó LangChain4j. Si vas a crear agentes de IA en Java con el ADK, no dudes en enviarnos un mensaje a @glaforge en Twitter/X o @glaforge.dev en Bluesky. Queremos conocer tus excelentes casos de uso.