El ADK para Java ahora está disponible para modelos de lenguaje de terceros a través de la integración con LangChain4j

16 DE SEPTIEMBRE DE 2025

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.

Integración de LangChain4j para una gran variedad de modelos

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.

Ejecutar Gemma 3 con Docker Model Runner

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

Shell

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>

XML

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();

Java

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();

Java

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.

Ejecutar Qwen 3 con Ollama

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>

XML

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();

Java

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();

Java

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.

Nuevas funciones de esta versión

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:

Capacidades de herramientas ampliadas: Mejoramos en gran medida la forma en que creas y administras las herramientas.
- 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.
- Soporte asíncrono mejorado: 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.
- Mejor control del bucle: El nuevo campo 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.
Lógica y memoria del agente avanzadas:
- Devoluciones de llamada encadenadas: Agregamos compatibilidad con devoluciones de llamada encadenadas para eventos de 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.
- Nueva memoria y recuperación: Esta versión presenta un 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.
Entre las otras mejoras clave, se incluyen un POM principal y el Maven Wrapper (./mvnw), lo que garantiza un proceso de compilación coherente y sencillo para todos los colaboradores.

Pongamos a trabajar a esos agentes de IA

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.

publicado en: