Merge branch '1.5.x' into 2.0.x

Author: sdelamo

micronaut-langchain4j-core/src/main/java/io/micronaut/langchain4j/aiservices/AiServiceFactory.java

@@ -15,15 +15,14 @@
  */
 package io.micronaut.langchain4j.aiservices;
 
-import dev.langchain4j.memory.chat.MessageWindowChatMemory;
+import dev.langchain4j.memory.chat.ChatMemoryProvider;
 import dev.langchain4j.model.chat.ChatModel;
 import dev.langchain4j.model.chat.StreamingChatModel;
 import dev.langchain4j.model.embedding.EmbeddingModel;
 import dev.langchain4j.model.moderation.ModerationModel;
 import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;
 import dev.langchain4j.service.AiServices;
 import dev.langchain4j.store.embedding.EmbeddingStore;
-import dev.langchain4j.store.memory.chat.InMemoryChatMemoryStore;
 import io.micronaut.context.BeanContext;
 import io.micronaut.context.BeanProvider;
 import io.micronaut.context.Qualifier;
@@ -90,13 +89,7 @@ protected AiServices<Object> createAiServices(
 
         lookupByNameOrDefault(name, ModerationModel.class, builder::moderationModel);
 
-        // default to in-memory chat store, but allow replacement
-        lookupByNameOrDefault(name, InMemoryChatMemoryStore.class, new InMemoryChatMemoryStore(), (store) -> builder.chatMemory(
-            MessageWindowChatMemory.builder()
-                .maxMessages(10)
-                .chatMemoryStore(store)
-                .build()
-        ));
+        lookupByNameOrDefault(name, ChatMemoryProvider.class, builder::chatMemoryProvider);
 
         lookupByNameOrDefault(name, EmbeddingModel.class, null, embeddingModel ->
             lookupByNameOrDefault(name, EmbeddingStore.class, null, embeddingStore ->
@@ -128,7 +121,7 @@ private <T> void lookupByNameOrDefault(String name, Argument<T> beanType, @Nulla
             configurer.accept(defaultValue);
         }
 
-        provider.ifPresent(configurer);
-        provider.find(qualifier).ifPresent(configurer);
+        provider.find(qualifier).ifPresentOrElse(configurer,
+            () -> provider.ifPresent(configurer));
     }
 }

micronaut-langchain4j-core/src/main/java/io/micronaut/langchain4j/embedding/package-info.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2017-2025 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Classes related with the creation of in-memory {@link dev.langchain4j.store.embedding.EmbeddingStore}.
+ */
+@Requires(property = "langchain4j.in-memory.embedding-store.enabled", value = StringUtils.TRUE, defaultValue = StringUtils.TRUE)
+@Configuration
+package io.micronaut.langchain4j.embedding;
+
+import io.micronaut.context.annotation.Configuration;
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.core.util.StringUtils;
+

micronaut-langchain4j-core/src/main/java/io/micronaut/langchain4j/store/memory/chat/MessageWindowChatMemoryFactory.java

@@ -29,8 +29,7 @@
  */
 @Factory
 @Internal
-
-class MessageWindowChatMemoryFactory {
+public class MessageWindowChatMemoryFactory {
 
     /**
      *
@@ -39,7 +38,7 @@ class MessageWindowChatMemoryFactory {
      */
     @Prototype
     @EachBean(ChatMemoryStore.class)
-    MessageWindowChatMemory.@NonNull Builder createMessageWindowChatMemoryBuilder(@NonNull ChatMemoryStore chatMemoryStore,
+    public MessageWindowChatMemory.@NonNull Builder createMessageWindowChatMemoryBuilder(@NonNull ChatMemoryStore chatMemoryStore,
                                                                          @NonNull MessageWindowChatMemoryConfiguration config) {
         return MessageWindowChatMemory.builder()
             .maxMessages(config.getMaxMessages())

micronaut-langchain4j-core/src/main/java/io/micronaut/langchain4j/store/memory/chat/inmemory/InMemoryMessageWindowChatMemoryProvider.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2017-2025 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.micronaut.langchain4j.store.memory.chat.inmemory;
+
+import dev.langchain4j.Internal;
+import dev.langchain4j.memory.ChatMemory;
+import dev.langchain4j.memory.chat.ChatMemoryProvider;
+import dev.langchain4j.store.memory.chat.ChatMemoryStore;
+import io.micronaut.langchain4j.store.memory.chat.MessageWindowChatMemoryConfiguration;
+import io.micronaut.langchain4j.store.memory.chat.MessageWindowChatMemoryFactory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+
+/**
+ * {@link ChatMemoryProvider} implementation that creates {@link dev.langchain4j.memory.chat.MessageWindowChatMemory}.
+ */
+@Internal
+@Named("InMemoryMessageWindow")
+@Singleton
+class InMemoryMessageWindowChatMemoryProvider implements ChatMemoryProvider {
+    private final MessageWindowChatMemoryFactory messageWindowChatMemoryFactory;
+    private final InMemoryChatMemoryStoreFactory inMemoryChatMemoryStoreFactory;
+    private final MessageWindowChatMemoryConfiguration config;
+
+    InMemoryMessageWindowChatMemoryProvider(MessageWindowChatMemoryFactory messageWindowChatMemoryFactory,
+                                            InMemoryChatMemoryStoreFactory inMemoryChatMemoryStoreFactory,
+                                            MessageWindowChatMemoryConfiguration config) {
+        this.messageWindowChatMemoryFactory = messageWindowChatMemoryFactory;
+        this.inMemoryChatMemoryStoreFactory = inMemoryChatMemoryStoreFactory;
+        this.config = config;
+    }
+
+    @Override
+    public ChatMemory get(Object memoryId) {
+        ChatMemoryStore chatMemoryStore = inMemoryChatMemoryStoreFactory.chatMemoryStore();
+        return messageWindowChatMemoryFactory.createMessageWindowChatMemoryBuilder(chatMemoryStore, config)
+            .id(memoryId)
+            .build();
+    }
+}

micronaut-langchain4j-core/src/main/java/io/micronaut/langchain4j/utils/ImageContentUtils.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2017-2025 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.micronaut.langchain4j.utils;
+
+import dev.langchain4j.data.image.Image;
+import dev.langchain4j.data.message.ImageContent;
+import io.micronaut.core.annotation.Internal;
+import io.micronaut.core.annotation.NonNull;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Base64;
+
+/**
+ * Utility class to create {@link ImageContent} instances.
+ */
+@Internal
+public final class ImageContentUtils {
+    private ImageContentUtils() {
+    }
+
+    /**
+     *
+     * @param is InputStream
+     * @param mediaType MediaType
+     * @return Image Content
+     * @throws IOException exception triggered reading bytes from inputStream
+     */
+    @NonNull
+    public static ImageContent imageContent(@NonNull InputStream is, @NonNull String mediaType) throws IOException {
+        byte[] bytes = is.readAllBytes();
+        return imageContent(bytes, mediaType);
+    }
+
+    /**
+     *
+     * @param imageBytes Image bytes
+     * @param mediaType Media type
+     * @return Image Content
+     */
+    @NonNull
+    public static ImageContent imageContent(@NonNull byte[] imageBytes, @NonNull String mediaType) {
+        String base64 = Base64.getEncoder().encodeToString(imageBytes);
+        return imageContent(base64, mediaType);
+    }
+
+
+    /**
+     *
+     * @param base64 Image content Base 64 encoded
+     * @param mediaType Media type
+     * @return Image Content
+     */
+    @NonNull
+    public static ImageContent imageContent(@NonNull String base64, @NonNull String mediaType) {
+        return ImageContent.from(Image.builder()
+            .base64Data(base64)
+            .mimeType(mediaType)
+            .build());
+    }
+}

micronaut-langchain4j-core/src/main/java/io/micronaut/langchain4j/utils/package-info.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2017-2025 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Utility classes to work with Langchain4j.
+ */
+package io.micronaut.langchain4j.utils;

micronaut-langchain4j-core/src/test/java/io/micronaut/langchain4j/store/memory/chat/inmemory/InMemoryMessageWindowChatMemoryProviderTest.java

@@ -0,0 +1,24 @@
+package io.micronaut.langchain4j.store.memory.chat.inmemory;
+
+import dev.langchain4j.memory.chat.ChatMemoryProvider;
+import io.micronaut.context.BeanContext;
+import io.micronaut.inject.qualifiers.Qualifiers;
+import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@MicronautTest(startApplication = false)
+class InMemoryMessageWindowChatMemoryProviderTest {
+
+    @Inject
+    BeanContext beanContext;
+
+    @Test
+    void messageWindowChatMemoryProvider() {
+        ChatMemoryProvider provider = beanContext.getBean(ChatMemoryProvider.class, Qualifiers.byName("InMemoryMessageWindow"));
+        assertNotNull(provider);
+        assertInstanceOf(InMemoryMessageWindowChatMemoryProvider.class, provider);
+    }
+}

micronaut-langchain4j-googleai-gemini/README.md

@@ -1 +1,10 @@
 To run the tests in this module. Define the environment variable `LANGCHAIN4J_GOOGLE_AI_GEMINI_API_KEY`.
+
+To obtain an API key for Google AI Gemini, you need to use [Google AI Studio](https://aistudio.google.com)
+
+- Sign in: Use your Google account to sign in
+- Get API Key: Once logged in, look for the "Get API key" option in the left sidebar or navigation menu
+- Create or Select Project: You'll either need to:
+  * Create a new API key in a new project, or
+  * Select an existing Google Cloud project if you have one
+- Copy the API Key: Once generated, copy the API key - it will look something like AIzaSy...

micronaut-langchain4j-googleai-gemini/src/main/java/io/micronaut/langchain4j/googleaigemini/GoogleaiGeminiModule.java

@@ -39,7 +39,7 @@
             impl = GoogleAiEmbeddingModel.class)
     },
     properties = {
-        @Lang4jConfig.Property(name = "modelName", common = true, required = true, defaultValue = "gemini-1.5-flash"),
+        @Lang4jConfig.Property(name = "modelName", common = true, required = true, defaultValue = "gemini-2.5-flash"),
         @Lang4jConfig.Property(name = "apiKey", common = true, required = true)
     }
 )

micronaut-langchain4j-googleai-gemini/src/test/java/io/micronaut/langchain4j/googleaigemini/GoogleAiGeminiImageContentTest.java

@@ -0,0 +1,61 @@
+package io.micronaut.langchain4j.googleaigemini;
+
+import dev.langchain4j.data.message.ImageContent;
+import dev.langchain4j.model.chat.ChatModel;
+import dev.langchain4j.service.SystemMessage;
+import dev.langchain4j.service.UserMessage;
+import dev.langchain4j.store.embedding.EmbeddingStore;
+import io.micronaut.context.BeanContext;
+import io.micronaut.context.annotation.Property;
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.core.util.StringUtils;
+import io.micronaut.langchain4j.annotation.AiService;
+import io.micronaut.langchain4j.utils.ImageContentUtils;
+import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Locale;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@EnabledIfEnvironmentVariable(
+    named = "LANGCHAIN4J_GOOGLE_AI_GEMINI_API_KEY",
+    matches = ".+"
+)
+@Property(name = "langchain4j.google-ai-gemini.chat-model.log-requests", value = StringUtils.TRUE)
+@Property(name = "langchain4j.google-ai-gemini.chat-model.log-responses", value = StringUtils.TRUE)
+@Property(name = "spec.name", value = "GoogleAiGeminiImageContentTest")
+@MicronautTest(startApplication = false)
+class GoogleAiGeminiImageContentTest {
+    @Inject
+    BeanContext beanContext;
+
+    @Test
+    void testImage(ChatService chatService) throws IOException {
+        assertTrue(beanContext.containsBean(ChatModel.class));
+        assertFalse(beanContext.containsBean(EmbeddingStore.class));
+        try (InputStream is = getClass().getClassLoader().getResourceAsStream("cat.jpg")) {
+            if (is == null) {
+                throw new IllegalStateException("Resource cat.jpg not found");
+            }
+
+            var imageContent = ImageContentUtils.imageContent(is, "image/jpeg");
+            String response = assertDoesNotThrow(() -> chatService.chat("What animal is shown in this image?", List.of(imageContent)));
+            assertTrue(response.toLowerCase(Locale.ROOT).contains("cat"), response + " did not contain 'cat'");
+        }
+    }
+
+    @Requires(property = "spec.name", value = "GoogleAiGeminiImageContentTest")
+    @AiService
+    interface ChatService {
+        @SystemMessage("You are a helpful AI assistant.")
+        String chat(@UserMessage String userMessage, @UserMessage List<ImageContent> images);
+    }
+}