Construir aplicaciones con Spring Boot, LangChain4j y Ollama

Cuando se habla de desarrollar aplicaciones con LLMs, casi todos los ejemplos utilizan servicios en la nube como OpenAI, Gemini o Claude. Sin embargo, para aprender, desarrollar prototipos o incluso construir aplicaciones internas, ejecutar un modelo localmente suele ser una excelente alternativa.

El objetivo es mostrar que integrar un LLM en una aplicación Java puede ser tan simple como consumir cualquier otro servicio.

Ya hablamos de LangChain4j

Necesitamos:

• Java 21
• Spring Boot 3.5+
• Ollama instalado

Descargamos un modelo.

ollama pull llama3.2

Y lo ejecutamos

ollama serve

Por defecto queda escuchando en

http://localhost:11434

Ahora creamos el proyecto spring boot y agregamos la dependencia.

Con Maven:

<dependency>

    <groupId>dev.langchain4j</groupId>

    <artifactId>langchain4j</artifactId>

    <version>1.1.0</version>

</dependency>

<dependency>

    <groupId>dev.langchain4j</groupId>

    <artifactId>langchain4j-ollama</artifactId>

    <version>1.1.0</version>

</dependency>

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-web</artifactId>

</dependency>

Creamos un Bean.

@Configuration

public class AIConfiguration {

    @Bean

    ChatLanguageModel chatLanguageModel() {

        return OllamaChatModel.builder()

                .baseUrl("http://localhost:11434")

                .modelName("llama3.2")

                .temperature(0.2)

                .build();

    }

}

Nada más.

No hay API Keys.

No hay cuentas.

No hay servicios externos.

Una de las características más interesantes de LangChain4j es que los prompts pueden representarse mediante interfaces Java.

interface Assistant {

    String chat(String message);

}

Luego simplemente creamos una implementación dinámica.

@Bean

Assistant assistant(ChatLanguageModel model){

    return AiServices.create(

            Assistant.class,

            model

    );

}

Desde este momento tenemos un objeto Java completamente funcional.

Creamos un Controller.

@RestController

@RequestMapping("/chat")

public class ChatController {

    private final Assistant assistant;

    public ChatController(Assistant assistant) {

        this.assistant = assistant;

    }

    @GetMapping

    public String chat(@RequestParam String message){

        return assistant.chat(message);

    }

}

Probamos la aplicación.

GET /chat?message=Explain what Spring Boot is

Respuesta:

Spring Boot is...

Así de simple.

Podemos indicar el comportamiento del asistente mediante anotaciones.

interface Assistant {

    @SystemMessage("""

        You are a senior Java architect.

        Keep answers under 150 words.

        """)

    String chat(String message);

}

Ahora todas las respuestas respetarán ese contexto.

También podemos utilizar parámetros.

interface Translator {

    @SystemMessage("""

        You are a professional translator.

        Translate everything to {{language}}.

        """)

    String translate(

            @V("language") String language,

            @UserMessage String text);

}

Uso:

translator.translate(

    "Spanish",

    "Spring Boot is awesome."

);

LangChain4j permite agregar memoria con muy poco código.

@Bean

ChatMemory chatMemory() {

    return MessageWindowChatMemory.withMaxMessages(20);

}

Luego la asociamos al servicio.

Assistant assistant(ChatLanguageModel model,

                    ChatMemory memory){

    return AiServices.builder(Assistant.class)

            .chatLanguageModel(model)

            .chatMemory(memory)

            .build();

}

Ahora el modelo recordará el contexto de la conversación.

Este ejemplo apenas muestra la superficie.

LangChain4j también incorpora soporte para:

• Retrieval Augmented Generation (RAG)
• Embeddings
• Document Loaders
• Vector Stores
• Tools (Function Calling)
• Streaming
• Moderation
• AI Agents
• Structured Outputs

Todo ello manteniendo una API muy natural para desarrolladores Java.

Construyendo Aplicaciones Inteligentes con LangChain4j y Spring boot

LangChain4j es una poderosa biblioteca para crear aplicaciones que integran grandes modelos de lenguaje (LLMs) de manera estructurada y eficiente. Basado en el éxito de LangChain en el ecosistema de Python, LangChain4j lleva estas capacidades al mundo de Java, facilitando el desarrollo de aplicaciones que usan IA generativa.

Ya hablamos de LangChain4j

Creamos un proyecto básico de Spring Boot con módulos como Web y Configuration y luego agregamos la dependencia con maven:

   <dependency>

       <groupId>io.github.langchain4j</groupId>

       <artifactId>langchain4j</artifactId>

       <version>0.2.0</version>

   </dependency>

Configura tu proveedor de modelo, como OpenAI:

import io.github.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

@Configuration

public class LangChainConfig {

    @Bean

    public OpenAiChatModel openAiChatModel() {

        return OpenAiChatModel.builder()

                .apiKey("TU_CLAVE_API")

                .temperature(0.7)

                .maxTokens(500)

                .build();

    }

}

Implemente un controlador para manejar las solicitudes de los usuarios.

import io.github.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/api/chat")

public class ChatController {

    private final OpenAiChatModel chatModel;

    public ChatController(OpenAiChatModel chatModel) {

        this.chatModel = chatModel;

    }

    @PostMapping

    public String chat(@RequestBody String userInput) {

        return chatModel.chat(userInput).getContent();

    }

}

Ejecuta la aplicación Spring Boot y envía una solicitud POST a `/api/chat`:

curl -X POST http://localhost:8080/api/chat LangChain es un marco diseñado para trabajar con modelos de lenguaje para crear aplicaciones avanzadas de IA.

Para agregar memoria a las conversaciones:

import io.github.langchain4j.memory.ChatMemory;

import io.github.langchain4j.memory.InMemoryChatMemory;

import org.springframework.context.annotation.Bean;

@Configuration

public class LangChainConfig {

    @Bean

    public ChatMemory chatMemory() {

        return new InMemoryChatMemory();

    }

}

En el controlador, utiliza el ChatMemory para mantener el contexto entre solicitudes:

import io.github.langchain4j.memory.ChatMemory;

@RestController

@RequestMapping("/api/chat")

public class ChatController {

    private final OpenAiChatModel chatModel;

    private final ChatMemory chatMemory;

    public ChatController(OpenAiChatModel chatModel, ChatMemory chatMemory) {

        this.chatModel = chatModel;

        this.chatMemory = chatMemory;

    }

    @PostMapping

    public String chat(@RequestBody String userInput) {

        chatMemory.addUserMessage(userInput);

        String response = chatModel.chat(userInput).getContent();

        chatMemory.addAiMessage(response);

        return response;

    }

}

LangChain4j es una herramienta poderosa para desarrollar aplicaciones inteligentes en Java. Combinado con Spring, puedes crear servicios escalables que aprovechen lo mejor de la IA generativa. Desde aplicaciones conversacionales hasta sistemas de soporte, las posibilidades son infinitas.

LangChain4j: IA Generativa en Java

LangChain4j es un poderoso framework para construir aplicaciones de inteligencia artificial generativa en Java. Inspirado en el popular LangChain para Python y JavaScript, este marco permite integrar modelos de lenguaje como OpenAI GPT, Llama, o Hugging Face con herramientas avanzadas, flujos de trabajo y procesamiento dinámico.

LangChain4j proporciona herramientas para manejar modelos de lenguaje de manera modular y escalable. Algunas de sus características destacadas incluyen:

• Integración de Modelos de Lenguaje (LLMs): Interactúa fácilmente con GPT-4, GPT-3, o modelos personalizados.
• Encadenamiento de Operaciones: Diseña flujos complejos combinando varios modelos y herramientas.
• Contexto Extendido: Utiliza almacenamiento vectorial para manejar contextos largos.
• Herramientas de Razonamiento y Extracción: Construye aplicaciones como chatbots avanzados, asistentes de búsqueda, o sistemas de recomendación.

Antes de comenzar, agrega la dependencia en tu proyecto Maven o Gradle:

Veamos la dependencia de maven:

<dependency>

    <groupId>com.langchain4j</groupId>

    <artifactId>langchain4j-core</artifactId>

    <version>1.0.0</version>

</dependency>

o gradle:

implementation 'com.langchain4j:langchain4j-core:1.0.0'

Veamos un cliente básico para interactuar con OpenAI GPT:

import com.langchain4j.LangChain;

import com.langchain4j.llm.OpenAiClient;

public class LangChainExample {

    public static void main(String[] args) {

        OpenAiClient client = OpenAiClient.builder()

                .apiKey("tu-api-key")

                .build();

        String response = client.chat("¿Qué es LangChain4j?");

        System.out.println("Respuesta: " + response);

    }

}

Este ejemplo muestra cómo enviar una consulta y recibir una respuesta usando OpenAI GPT.

LangChain4j soporta herramientas como cadenas de procesamiento (`Chains`) para flujos más complejos.

Veamos un ejemplo de un Flujo con Memoria:

import com.langchain4j.chain.ConversationChain;

import com.langchain4j.memory.InMemoryMemory;

public class ConversationExample {

    public static void main(String[] args) {

        ConversationChain conversation = ConversationChain.builder()

                .llm(OpenAiClient.builder().apiKey("tu-api-key").build())

                .memory(new InMemoryMemory())

                .build();

        System.out.println(conversation.chat("Hola, ¿quién eres?"));

        System.out.println(conversation.chat("¿Recuerdas mi nombre?"));

    }

}

Aquí, InMemoryMemory permite que el modelo recuerde las interacciones previas.

LangChain4j admite almacenamiento vectorial, útil para aplicaciones de búsqueda semántica o contextos largos.

import com.langchain4j.vector.PineconeVectorStore;

public class VectorStoreExample {

    public static void main(String[] args) {

        PineconeVectorStore vectorStore = PineconeVectorStore.builder()

                .apiKey("tu-api-key")

                .environment("us-west1-gcp")

                .build();

        vectorStore.add("doc1", "Este es un ejemplo de texto.");

        System.out.println(vectorStore.search("texto relacionado", 1));

    }

}

LangChain4j extiende las capacidades de los modelos de lenguaje para aplicaciones empresariales en Java. Con su enfoque modular, herramientas avanzadas, y soporte para almacenamiento vectorial, se posiciona como una opción clave para proyectos de IA generativa en el ecosistema Java.

Y falto decir que se puede integrar con spring y otros frameworks, pero eso lo voy a dejar para otro post... 

Dejo link: https://docs.langchain4j.dev/